Support for Factory Contract Dependency in forge create

crates/cli/src/utils/cmd.rs

@@ -6,7 +6,7 @@ use foundry_common::{
     TestFunctionExt,
 };
 use foundry_compilers::{
-    artifacts::{CompactBytecode, Settings},
+    artifacts::{BytecodeObject, CompactBytecode, ConfigurableContractArtifact, Settings},
     cache::{CacheEntry, CompilerCache},
     utils::read_json_file,
     Artifact, ArtifactId, ProjectCompileOutput,
@@ -73,6 +73,40 @@ pub fn remove_contract(
     Ok((abi, bin, id))
 }
 
+#[derive(Debug, Clone)]
+pub struct ChildContract {
+    pub name: String,
+    pub bytecode: BytecodeObject,
+}
+
+/// Get child contracts from compiled output
+pub fn get_child_contracts(
+    output: ProjectCompileOutput,
+    parent_contract_name: &str,
+) -> Result<Vec<ChildContract>> {
+    let artifacts: Vec<(ArtifactId, ConfigurableContractArtifact)> =
+        output.into_artifacts().collect();
+    let mut child_contracts = Vec::new();
+
+    // Find all contracts that are not the parent contract
+    for (artifact_id, artifact) in artifacts {
+        let contract_name = &artifact_id.name;
+
+        if contract_name != parent_contract_name {
+            // This is a child contract (different name from parent)
+            if let Some(bytecode) = &artifact.bytecode {
+                let child_contract = ChildContract {
+                    name: contract_name.clone(),
+                    bytecode: bytecode.object.clone(),
+                };
+                child_contracts.push(child_contract);
+            }
+        }
+    }
+
+    Ok(child_contracts)
+}
+
 /// Helper function for finding a contract by ContractName
 // TODO: Is there a better / more ergonomic way to get the artifacts given a project and a
 // contract name?

crates/forge/Cargo.toml

@@ -56,6 +56,7 @@ alloy-rpc-types.workspace = true
 alloy-serde.workspace = true
 alloy-signer.workspace = true
 alloy-transport.workspace = true
+alloy-signer-local.workspace = true
 
 clap = { version = "4", features = ["derive", "env", "unicode", "wrap_help"] }
 clap_complete = "4"
@@ -84,6 +85,9 @@ watchexec-signals = "4.0"
 clearscreen = "4.0"
 evm-disassembler.workspace = true
 
+hex = "0.4.3"
+codec = { package = "parity-scale-codec", version = "3.7.5", default-features = false, features = ["derive"] }
+
 # doc server
 axum = { workspace = true, features = ["ws"] }
 tower-http = { workspace = true, features = ["fs"] }

crates/forge/src/cmd/create.rs

@@ -10,11 +10,13 @@ use alloy_serde::WithOtherFields;
 use alloy_signer::Signer;
 use alloy_transport::TransportError;
 use clap::{Parser, ValueHint};
-use eyre::{Context, Result};
+
+use codec::{Compact, Encode};
+use eyre::{Context, OptionExt, Result};
 use forge_verify::{RetryArgs, VerifierArgs, VerifyArgs};
 use foundry_cli::{
     opts::{BuildOpts, EthereumOpts, EtherscanOpts, TransactionOpts},
-    utils::{self, read_constructor_args_file, remove_contract, LoadConfig},
+    utils::{self, get_child_contracts, read_constructor_args_file, remove_contract, LoadConfig},
 };
 use foundry_common::{
     compile::{self},
@@ -34,7 +36,7 @@ use foundry_config::{
 };
 use serde_json::json;
 use std::{borrow::Borrow, marker::PhantomData, path::PathBuf, sync::Arc, time::Duration};
-
+use tracing::debug;
 merge_impl_figment_convert!(CreateArgs, build, eth);
 
 /// CLI arguments for `forge create`.
@@ -100,11 +102,54 @@ pub struct CreateArgs {
     retry: RetryArgs,
 }
 
+/// Uploads a child contract to a blockchain network using the Alloy framework.
+async fn upload_child_contract_alloy(
+    rpc_url: &str,
+    private_key: String,
+    encoded_bytes: String,
+) -> Result<String> {
+    use alloy_primitives::{Address, U256};
+    use alloy_provider::Provider;
+    use alloy_rpc_types::TransactionRequest;
+    use alloy_serde::WithOtherFields;
+    use alloy_signer_local::PrivateKeySigner;
+    use foundry_common::provider::ProviderBuilder;
+    use std::str::FromStr;
+
+    // This wallet will be used to sign the deployment transaction
+    let wallet = PrivateKeySigner::from_str(&private_key)?;
+
+    // This establishes the connection to the target network and prepares for transaction signing
+    let provider = ProviderBuilder::new(rpc_url).build_with_wallet(EthereumWallet::new(wallet))?;
+
+    // Use the special "magic address" for child contract deployment
+    let magic_address: Address = "0x6d6f646c70792f70616464720000000000000000".parse()?;
+
+    // Convert the hex-encoded bytecode string to actual bytes for the transaction input
+    // Remove "0x" prefix if present before decoding
+    let input_bytes = hex::decode(encoded_bytes.trim_start_matches("0x"))?;
+
+    // Construct the transaction request
+    let tx = TransactionRequest::default()
+        .to(magic_address)
+        .input(input_bytes.into())
+        .value(U256::from(0u64));
+
+    // Wrap the transaction in WithOtherFields for proper serialization
+    let wrapped_tx = WithOtherFields::new(tx);
+
+    // Send the transaction to the network and wait for it to be included in a block
+    let pending_tx = provider.send_transaction(wrapped_tx).await?;
+    let receipt = pending_tx.get_receipt().await?;
+
+    // Return the transaction hash as a string for tracking and verification
+    Ok(receipt.transaction_hash.to_string())
+}
+
 impl CreateArgs {
     /// Executes the command to create a contract
     pub async fn run(mut self) -> Result<()> {
         let mut config = self.load_config()?;
-
         // Install missing dependencies.
         if install::install_missing_dependencies(&mut config) && config.auto_detect_remappings {
             // need to re-configure here to also catch additional remappings
@@ -120,7 +165,64 @@ impl CreateArgs {
             project.find_contract_path(&self.contract.name)?
         };
 
-        let output = compile::compile_target(&target_path, &project, shell::is_json())?;
+        let output: foundry_compilers::ProjectCompileOutput =
+            compile::compile_target(&target_path, &project, shell::is_json())?;
+
+        match get_child_contracts(output.clone(), &self.contract.name) {
+            Ok(child_contracts) => {
+                if child_contracts.is_empty() {
+                    debug!("No child contracts found for '{}'", self.contract.name);
+                } else {
+                    debug!(
+                        "Found {} child contract(s) for '{}':",
+                        child_contracts.len(),
+                        self.contract.name
+                    );
+                    for child in &child_contracts {
+                        match &child.bytecode {
+                            BytecodeObject::Bytecode(bytes) => {
+                                let scaled_encoded_bytes = bytes.encode();
+                                let storage_deposit_limit = Compact(10000000000u128);
+                                let encoded_storage_deposit_limit = storage_deposit_limit.encode();
+                                let combined_hex = "0x3c04".to_string() +
+                                    &hex::encode(&scaled_encoded_bytes) +
+                                    &hex::encode(&encoded_storage_deposit_limit);
+
+                                // Pass RPC URL and private key to upload_child_contract
+                                let rpc_url = config.get_rpc_url_or_localhost_http()?;
+                                let private_key = self
+                                    .eth
+                                    .wallet
+                                    .raw
+                                    .private_key
+                                    .clone()
+                                    .ok_or_eyre("Private key not provided")?;
+
+                                let tx_hash = upload_child_contract_alloy(
+                                    rpc_url.as_ref(),
+                                    private_key,
+                                    combined_hex,
+                                )
+                                .await?;
+                                debug!(
+                                    "Transaction sent! Hash: {:?} for child contract {:?}",
+                                    tx_hash, self.contract.name
+                                );
+                            }
+                            BytecodeObject::Unlinked(_) => {
+                                debug!(
+                                    "Bytecode: Available (unlinked) for child contract) {:?}",
+                                    self.contract.name
+                                );
+                            }
+                        };
+                    }
+                }
+            }
+            Err(e) => {
+                debug!("Error getting child contracts: {}", e);
+            }
+        }
 
         let (abi, bin, id) = remove_contract(output, &target_path, &self.contract.name)?;