1use crate::cmd::install;
2use alloy_chains::Chain;
3use alloy_dyn_abi::{DynSolValue, JsonAbiExt, Specifier};
4use alloy_json_abi::{Constructor, JsonAbi};
5use alloy_network::{AnyNetwork, AnyTransactionReceipt, EthereumWallet, TransactionBuilder};
6use alloy_primitives::{Address, Bytes, hex};
7use alloy_provider::{PendingTransactionError, Provider, ProviderBuilder};
8use alloy_rpc_types::TransactionRequest;
9use alloy_serde::WithOtherFields;
10use alloy_signer::Signer;
11use alloy_transport::TransportError;
12use clap::{Parser, ValueHint};
13use eyre::{Context, Result};
14use forge_verify::{RetryArgs, VerifierArgs, VerifyArgs};
15use foundry_cli::{
16 opts::{BuildOpts, EthereumOpts, EtherscanOpts, TransactionOpts},
17 utils::{self, LoadConfig, read_constructor_args_file, remove_contract},
18};
19use foundry_common::{
20 compile::{self},
21 fmt::parse_tokens,
22 shell,
23};
24use foundry_compilers::{
25 ArtifactId, artifacts::BytecodeObject, info::ContractInfo, utils::canonicalize,
26};
27use foundry_config::{
28 Config,
29 figment::{
30 self, Metadata, Profile,
31 value::{Dict, Map},
32 },
33 merge_impl_figment_convert,
34};
35use serde_json::json;
36use std::{borrow::Borrow, marker::PhantomData, path::PathBuf, sync::Arc, time::Duration};
37
38merge_impl_figment_convert!(CreateArgs, build, eth);
39
40#[derive(Clone, Debug, Parser)]
42pub struct CreateArgs {
43 contract: ContractInfo,
45
46 #[arg(
48 long,
49 num_args(1..),
50 conflicts_with = "constructor_args_path",
51 value_name = "ARGS",
52 allow_hyphen_values = true,
53 )]
54 constructor_args: Vec<String>,
55
56 #[arg(
58 long,
59 value_hint = ValueHint::FilePath,
60 value_name = "PATH",
61 )]
62 constructor_args_path: Option<PathBuf>,
63
64 #[arg(long)]
66 pub broadcast: bool,
67
68 #[arg(long)]
70 verify: bool,
71
72 #[arg(long, requires = "from")]
74 unlocked: bool,
75
76 #[arg(long, requires = "verify")]
81 show_standard_json_input: bool,
82
83 #[arg(long, env = "ETH_TIMEOUT")]
85 pub timeout: Option<u64>,
86
87 #[command(flatten)]
88 build: BuildOpts,
89
90 #[command(flatten)]
91 tx: TransactionOpts,
92
93 #[command(flatten)]
94 eth: EthereumOpts,
95
96 #[command(flatten)]
97 pub verifier: VerifierArgs,
98
99 #[command(flatten)]
100 retry: RetryArgs,
101}
102
103impl CreateArgs {
104 pub async fn run(mut self) -> Result<()> {
106 let mut config = self.load_config()?;
107
108 if install::install_missing_dependencies(&mut config) && config.auto_detect_remappings {
110 config = self.load_config()?;
112 }
113
114 let project = config.project()?;
116
117 let target_path = if let Some(ref mut path) = self.contract.path {
118 canonicalize(project.root().join(path))?
119 } else {
120 project.find_contract_path(&self.contract.name)?
121 };
122
123 let output = compile::compile_target(&target_path, &project, shell::is_json())?;
124
125 let (abi, bin, id) = remove_contract(output, &target_path, &self.contract.name)?;
126
127 let bin = match bin.object {
128 BytecodeObject::Bytecode(_) => bin.object,
129 _ => {
130 let link_refs = bin
131 .link_references
132 .iter()
133 .flat_map(|(path, names)| {
134 names.keys().map(move |name| format!("\t{name}: {path}"))
135 })
136 .collect::<Vec<String>>()
137 .join("\n");
138 eyre::bail!(
139 "Dynamic linking not supported in `create` command - deploy the following library contracts first, then provide the address to link at compile time\n{}",
140 link_refs
141 )
142 }
143 };
144
145 let params = if let Some(constructor) = &abi.constructor {
147 let constructor_args =
148 self.constructor_args_path.clone().map(read_constructor_args_file).transpose()?;
149 self.parse_constructor_args(
150 constructor,
151 constructor_args.as_deref().unwrap_or(&self.constructor_args),
152 )?
153 } else {
154 vec![]
155 };
156
157 let provider = utils::get_provider(&config)?;
158
159 let chain_id = if let Some(chain_id) = self.chain_id() {
161 chain_id
162 } else {
163 provider.get_chain_id().await?
164 };
165
166 let dry_run = !self.broadcast;
168
169 if self.unlocked {
170 let sender = self.eth.wallet.from.expect("required");
172 self.deploy(
173 abi,
174 bin,
175 params,
176 provider,
177 chain_id,
178 sender,
179 config.transaction_timeout,
180 id,
181 dry_run,
182 )
183 .await
184 } else {
185 let signer = self.eth.wallet.signer().await?;
187 let deployer = signer.address();
188 let provider = ProviderBuilder::<_, _, AnyNetwork>::default()
189 .wallet(EthereumWallet::new(signer))
190 .connect_provider(provider);
191 self.deploy(
192 abi,
193 bin,
194 params,
195 provider,
196 chain_id,
197 deployer,
198 config.transaction_timeout,
199 id,
200 dry_run,
201 )
202 .await
203 }
204 }
205
206 fn chain_id(&self) -> Option<u64> {
208 self.eth.etherscan.chain.map(|chain| chain.id())
209 }
210
211 async fn verify_preflight_check(
218 &self,
219 constructor_args: Option<String>,
220 chain: u64,
221 id: &ArtifactId,
222 ) -> Result<()> {
223 let mut verify = VerifyArgs {
226 address: Default::default(),
227 contract: Some(self.contract.clone()),
228 compiler_version: Some(id.version.to_string()),
229 constructor_args,
230 constructor_args_path: None,
231 num_of_optimizations: None,
232 etherscan: EtherscanOpts {
233 key: self.eth.etherscan.key.clone(),
234 chain: Some(chain.into()),
235 },
236 rpc: Default::default(),
237 flatten: false,
238 force: false,
239 skip_is_verified_check: true,
240 watch: true,
241 retry: self.retry,
242 libraries: self.build.libraries.clone(),
243 root: None,
244 verifier: self.verifier.clone(),
245 via_ir: self.build.via_ir,
246 evm_version: self.build.compiler.evm_version,
247 show_standard_json_input: self.show_standard_json_input,
248 guess_constructor_args: false,
249 compilation_profile: Some(id.profile.to_string()),
250 language: None,
251 };
252
253 let config = verify.load_config()?;
256 verify.etherscan.key =
257 config.get_etherscan_config_with_chain(Some(chain.into()))?.map(|c| c.key);
258
259 let context = verify.resolve_context().await?;
260
261 verify.verification_provider()?.preflight_verify_check(verify, context).await?;
262 Ok(())
263 }
264
265 #[expect(clippy::too_many_arguments)]
267 async fn deploy<P: Provider<AnyNetwork>>(
268 self,
269 abi: JsonAbi,
270 bin: BytecodeObject,
271 args: Vec<DynSolValue>,
272 provider: P,
273 chain: u64,
274 deployer_address: Address,
275 timeout: u64,
276 id: ArtifactId,
277 dry_run: bool,
278 ) -> Result<()> {
279 let bin = bin.into_bytes().unwrap_or_default();
280 if bin.is_empty() {
281 eyre::bail!("no bytecode found in bin object for {}", self.contract.name)
282 }
283
284 let provider = Arc::new(provider);
285 let factory = ContractFactory::new(abi.clone(), bin.clone(), provider.clone(), timeout);
286
287 let is_args_empty = args.is_empty();
288 let mut deployer =
289 factory.deploy_tokens(args.clone()).context("failed to deploy contract").map_err(|e| {
290 if is_args_empty {
291 e.wrap_err("no arguments provided for contract constructor; consider --constructor-args or --constructor-args-path")
292 } else {
293 e
294 }
295 })?;
296 let is_legacy = self.tx.legacy || Chain::from(chain).is_legacy();
297
298 deployer.tx.set_from(deployer_address);
299 deployer.tx.set_chain_id(chain);
300 if deployer.tx.to.is_none() {
302 deployer.tx.set_create();
303 }
304 deployer.tx.set_nonce(if let Some(nonce) = self.tx.nonce {
305 Ok(nonce.to())
306 } else {
307 provider.get_transaction_count(deployer_address).await
308 }?);
309
310 if let Some(value) = self.tx.value {
312 deployer.tx.set_value(value);
313 }
314
315 deployer.tx.set_gas_limit(if let Some(gas_limit) = self.tx.gas_limit {
316 Ok(gas_limit.to())
317 } else {
318 provider.estimate_gas(deployer.tx.clone()).await
319 }?);
320
321 if is_legacy {
322 let gas_price = if let Some(gas_price) = self.tx.gas_price {
323 gas_price.to()
324 } else {
325 provider.get_gas_price().await?
326 };
327 deployer.tx.set_gas_price(gas_price);
328 } else {
329 let estimate = provider.estimate_eip1559_fees().await.wrap_err("Failed to estimate EIP1559 fees. This chain might not support EIP1559, try adding --legacy to your command.")?;
330 let priority_fee = if let Some(priority_fee) = self.tx.priority_gas_price {
331 priority_fee.to()
332 } else {
333 estimate.max_priority_fee_per_gas
334 };
335 let max_fee = if let Some(max_fee) = self.tx.gas_price {
336 max_fee.to()
337 } else {
338 estimate.max_fee_per_gas
339 };
340
341 deployer.tx.set_max_fee_per_gas(max_fee);
342 deployer.tx.set_max_priority_fee_per_gas(priority_fee);
343 }
344
345 let mut constructor_args = None;
347 if self.verify {
348 if !args.is_empty() {
349 let encoded_args = abi
350 .constructor()
351 .ok_or_else(|| eyre::eyre!("could not find constructor"))?
352 .abi_encode_input(&args)?;
353 constructor_args = Some(hex::encode(encoded_args));
354 }
355
356 self.verify_preflight_check(constructor_args.clone(), chain, &id).await?;
357 }
358
359 if dry_run {
360 if !shell::is_json() {
361 sh_warn!("Dry run enabled, not broadcasting transaction\n")?;
362
363 sh_println!("Contract: {}", self.contract.name)?;
364 sh_println!(
365 "Transaction: {}",
366 serde_json::to_string_pretty(&deployer.tx.clone())?
367 )?;
368 sh_println!("ABI: {}\n", serde_json::to_string_pretty(&abi)?)?;
369
370 sh_warn!(
371 "To broadcast this transaction, add --broadcast to the previous command. See forge create --help for more."
372 )?;
373 } else {
374 let output = json!({
375 "contract": self.contract.name,
376 "transaction": &deployer.tx,
377 "abi":&abi
378 });
379 sh_println!("{}", serde_json::to_string_pretty(&output)?)?;
380 }
381
382 return Ok(());
383 }
384
385 let (deployed_contract, receipt) = deployer.send_with_receipt().await?;
387
388 let address = deployed_contract;
389 if shell::is_json() {
390 let output = json!({
391 "deployer": deployer_address.to_string(),
392 "deployedTo": address.to_string(),
393 "transactionHash": receipt.transaction_hash
394 });
395 sh_println!("{}", serde_json::to_string_pretty(&output)?)?;
396 } else {
397 sh_println!("Deployer: {deployer_address}")?;
398 sh_println!("Deployed to: {address}")?;
399 sh_println!("Transaction hash: {:?}", receipt.transaction_hash)?;
400 };
401
402 if !self.verify {
403 return Ok(());
404 }
405
406 sh_println!("Starting contract verification...")?;
407
408 let num_of_optimizations = if let Some(optimizer) = self.build.compiler.optimize {
409 if optimizer { Some(self.build.compiler.optimizer_runs.unwrap_or(200)) } else { None }
410 } else {
411 self.build.compiler.optimizer_runs
412 };
413
414 let verify = VerifyArgs {
415 address,
416 contract: Some(self.contract),
417 compiler_version: Some(id.version.to_string()),
418 constructor_args,
419 constructor_args_path: None,
420 num_of_optimizations,
421 etherscan: EtherscanOpts { key: self.eth.etherscan.key(), chain: Some(chain.into()) },
422 rpc: Default::default(),
423 flatten: false,
424 force: false,
425 skip_is_verified_check: true,
426 watch: true,
427 retry: self.retry,
428 libraries: self.build.libraries.clone(),
429 root: None,
430 verifier: self.verifier,
431 via_ir: self.build.via_ir,
432 evm_version: self.build.compiler.evm_version,
433 show_standard_json_input: self.show_standard_json_input,
434 guess_constructor_args: false,
435 compilation_profile: Some(id.profile.to_string()),
436 language: None,
437 };
438 sh_println!("Waiting for {} to detect contract deployment...", verify.verifier.verifier)?;
439 verify.run().await
440 }
441
442 fn parse_constructor_args(
447 &self,
448 constructor: &Constructor,
449 constructor_args: &[String],
450 ) -> Result<Vec<DynSolValue>> {
451 let mut params = Vec::with_capacity(constructor.inputs.len());
452 for (input, arg) in constructor.inputs.iter().zip(constructor_args) {
453 let ty = input
455 .resolve()
456 .wrap_err_with(|| format!("Could not resolve constructor arg: input={input}"))?;
457 params.push((ty, arg));
458 }
459 let params = params.iter().map(|(ty, arg)| (ty, arg.as_str()));
460 parse_tokens(params).map_err(Into::into)
461 }
462}
463
464impl figment::Provider for CreateArgs {
465 fn metadata(&self) -> Metadata {
466 Metadata::named("Create Args Provider")
467 }
468
469 fn data(&self) -> Result<Map<Profile, Dict>, figment::Error> {
470 let mut dict = Dict::default();
471 if let Some(timeout) = self.timeout {
472 dict.insert("transaction_timeout".to_string(), timeout.into());
473 }
474 Ok(Map::from([(Config::selected_profile(), dict)]))
475 }
476}
477
478pub type ContractFactory<P> = DeploymentTxFactory<P>;
484
485#[derive(Debug)]
489#[must_use = "ContractDeploymentTx does nothing unless you `send` it"]
490pub struct ContractDeploymentTx<P, C> {
491 pub deployer: Deployer<P>,
493 _contract: PhantomData<C>,
497}
498
499impl<P: Clone, C> Clone for ContractDeploymentTx<P, C> {
500 fn clone(&self) -> Self {
501 Self { deployer: self.deployer.clone(), _contract: self._contract }
502 }
503}
504
505impl<P, C> From<Deployer<P>> for ContractDeploymentTx<P, C> {
506 fn from(deployer: Deployer<P>) -> Self {
507 Self { deployer, _contract: PhantomData }
508 }
509}
510
511#[derive(Clone, Debug)]
513#[must_use = "Deployer does nothing unless you `send` it"]
514pub struct Deployer<P> {
515 pub tx: WithOtherFields<TransactionRequest>,
517 client: P,
518 confs: usize,
519 timeout: u64,
520}
521
522impl<P: Provider<AnyNetwork>> Deployer<P> {
523 pub async fn send_with_receipt(
527 self,
528 ) -> Result<(Address, AnyTransactionReceipt), ContractDeploymentError> {
529 let receipt = self
530 .client
531 .borrow()
532 .send_transaction(self.tx)
533 .await?
534 .with_required_confirmations(self.confs as u64)
535 .with_timeout(Some(Duration::from_secs(self.timeout)))
536 .get_receipt()
537 .await?;
538
539 let address =
540 receipt.contract_address.ok_or(ContractDeploymentError::ContractNotDeployed)?;
541
542 Ok((address, receipt))
543 }
544}
545
546#[derive(Clone, Debug)]
550pub struct DeploymentTxFactory<P> {
551 client: P,
552 abi: JsonAbi,
553 bytecode: Bytes,
554 timeout: u64,
555}
556
557impl<P: Provider<AnyNetwork> + Clone> DeploymentTxFactory<P> {
558 pub fn new(abi: JsonAbi, bytecode: Bytes, client: P, timeout: u64) -> Self {
562 Self { client, abi, bytecode, timeout }
563 }
564
565 pub fn deploy_tokens(
568 self,
569 params: Vec<DynSolValue>,
570 ) -> Result<Deployer<P>, ContractDeploymentError> {
571 let data: Bytes = match (self.abi.constructor(), params.is_empty()) {
573 (None, false) => return Err(ContractDeploymentError::ConstructorError),
574 (None, true) => self.bytecode.clone(),
575 (Some(constructor), _) => {
576 let input: Bytes = constructor
577 .abi_encode_input(¶ms)
578 .map_err(ContractDeploymentError::DetokenizationError)?
579 .into();
580 self.bytecode.iter().copied().chain(input).collect()
582 }
583 };
584
585 let tx = WithOtherFields::new(TransactionRequest::default().input(data.into()));
587
588 Ok(Deployer { client: self.client.clone(), tx, confs: 1, timeout: self.timeout })
589 }
590}
591
592#[derive(thiserror::Error, Debug)]
593pub enum ContractDeploymentError {
595 #[error("constructor is not defined in the ABI")]
596 ConstructorError,
597 #[error(transparent)]
598 DetokenizationError(#[from] alloy_dyn_abi::Error),
599 #[error("contract was not deployed")]
600 ContractNotDeployed,
601 #[error(transparent)]
602 RpcError(#[from] TransportError),
603}
604
605impl From<PendingTransactionError> for ContractDeploymentError {
606 fn from(_err: PendingTransactionError) -> Self {
607 Self::ContractNotDeployed
608 }
609}
610
611#[cfg(test)]
612mod tests {
613 use super::*;
614 use alloy_primitives::I256;
615
616 #[test]
617 fn can_parse_create() {
618 let args: CreateArgs = CreateArgs::parse_from([
619 "foundry-cli",
620 "src/Domains.sol:Domains",
621 "--verify",
622 "--retries",
623 "10",
624 "--delay",
625 "30",
626 ]);
627 assert_eq!(args.retry.retries, 10);
628 assert_eq!(args.retry.delay, 30);
629 }
630 #[test]
631 fn can_parse_chain_id() {
632 let args: CreateArgs = CreateArgs::parse_from([
633 "foundry-cli",
634 "src/Domains.sol:Domains",
635 "--verify",
636 "--retries",
637 "10",
638 "--delay",
639 "30",
640 "--chain-id",
641 "9999",
642 ]);
643 assert_eq!(args.chain_id(), Some(9999));
644 }
645
646 #[test]
647 fn test_parse_constructor_args() {
648 let args: CreateArgs = CreateArgs::parse_from([
649 "foundry-cli",
650 "src/Domains.sol:Domains",
651 "--constructor-args",
652 "Hello",
653 ]);
654 let constructor: Constructor = serde_json::from_str(r#"{"type":"constructor","inputs":[{"name":"_name","type":"string","internalType":"string"}],"stateMutability":"nonpayable"}"#).unwrap();
655 let params = args.parse_constructor_args(&constructor, &args.constructor_args).unwrap();
656 assert_eq!(params, vec![DynSolValue::String("Hello".to_string())]);
657 }
658
659 #[test]
660 fn test_parse_tuple_constructor_args() {
661 let args: CreateArgs = CreateArgs::parse_from([
662 "foundry-cli",
663 "src/Domains.sol:Domains",
664 "--constructor-args",
665 "[(1,2), (2,3), (3,4)]",
666 ]);
667 let constructor: Constructor = serde_json::from_str(r#"{"type":"constructor","inputs":[{"name":"_points","type":"tuple[]","internalType":"struct Point[]","components":[{"name":"x","type":"uint256","internalType":"uint256"},{"name":"y","type":"uint256","internalType":"uint256"}]}],"stateMutability":"nonpayable"}"#).unwrap();
668 let _params = args.parse_constructor_args(&constructor, &args.constructor_args).unwrap();
669 }
670
671 #[test]
672 fn test_parse_int_constructor_args() {
673 let args: CreateArgs = CreateArgs::parse_from([
674 "foundry-cli",
675 "src/Domains.sol:Domains",
676 "--constructor-args",
677 "-5",
678 ]);
679 let constructor: Constructor = serde_json::from_str(r#"{"type":"constructor","inputs":[{"name":"_name","type":"int256","internalType":"int256"}],"stateMutability":"nonpayable"}"#).unwrap();
680 let params = args.parse_constructor_args(&constructor, &args.constructor_args).unwrap();
681 assert_eq!(params, vec![DynSolValue::Int(I256::unchecked_from(-5), 256)]);
682 }
683}