From 24c62c078d5257d46ecefe6f698793e23789c2bc Mon Sep 17 00:00:00 2001 From: mohiiit Date: Tue, 5 Nov 2024 12:03:13 +0530 Subject: [PATCH] refactor: refactored code to take in cli params as well --- src/contract_clients/config.rs | 28 +-- src/contract_clients/utils.rs | 4 +- src/main.rs | 317 +++++++++++++++++++++++------ src/setup_scripts/account_setup.rs | 4 +- src/setup_scripts/braavos.rs | 6 +- src/setup_scripts/core_contract.rs | 6 +- src/setup_scripts/erc20_bridge.rs | 6 +- src/setup_scripts/eth_bridge.rs | 6 +- src/setup_scripts/udc.rs | 11 +- src/tests/erc20_bridge.rs | 4 +- src/tests/eth_bridge.rs | 4 +- src/tests/mod.rs | 18 +- 12 files changed, 293 insertions(+), 121 deletions(-) diff --git a/src/contract_clients/config.rs b/src/contract_clients/config.rs index cfe8997..21fc51a 100644 --- a/src/contract_clients/config.rs +++ b/src/contract_clients/config.rs @@ -2,7 +2,7 @@ use ethereum_instance::EthereumClient; use starknet::providers::jsonrpc::{HttpTransport, JsonRpcClient}; use starknet::providers::Url; -use crate::ConfigFile; +use crate::Config; pub struct Clients { eth_client: EthereumClient, @@ -18,32 +18,16 @@ impl Clients { &self.eth_client } - /// To deploy the instance of ethereum and starknet and returning the struct. - // pub async fn init(config: &CliArgs) -> Self { - // let client_instance = EthereumClient::attach( - // Option::from(config.eth_rpc.clone()), - // Option::from(config.eth_priv_key.clone()), - // Option::from(config.eth_chain_id), - // ) - // .unwrap(); - // - // let provider_l2 = JsonRpcClient::new(HttpTransport::new( - // Url::parse(&config.rollup_seq_url).expect("Failed to declare provider for app chain"), - // )); - // - // Self { eth_client: client_instance, provider_l2 } - // } - - pub async fn init_from_config(config_file: &ConfigFile) -> Self { + pub async fn init_from_config(config: &Config) -> Self { let client_instance = EthereumClient::attach( - Option::from(config_file.eth_rpc.clone()), - Option::from(config_file.eth_priv_key.clone()), - Option::from(config_file.eth_chain_id), + Option::from(config.eth_rpc.clone()), + Option::from(config.eth_priv_key.clone()), + Option::from(config.eth_chain_id), ) .unwrap(); let provider_l2 = JsonRpcClient::new(HttpTransport::new( - Url::parse(&config_file.rollup_seq_url).expect("Failed to declare provider for app chain"), + Url::parse(&config.rollup_seq_url).expect("Failed to declare provider for app chain"), )); Self { eth_client: client_instance, provider_l2 } diff --git a/src/contract_clients/utils.rs b/src/contract_clients/utils.rs index 490879f..e370330 100644 --- a/src/contract_clients/utils.rs +++ b/src/contract_clients/utils.rs @@ -21,7 +21,7 @@ use crate::contract_clients::legacy_class::CompressedLegacyContractClass; use crate::contract_clients::utils::DeclarationInput::{DeclarationInputs, LegacyDeclarationInputs}; use crate::helpers::account_actions::{get_contract_address_from_deploy_tx, AccountActions}; use crate::utils::{invoke_contract, save_to_json, wait_for_transaction, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub type RpcAccount<'a> = SingleOwnerAccount<&'a JsonRpcClient, LocalWallet>; pub async fn build_single_owner_account<'a>( @@ -75,7 +75,7 @@ pub fn generate_config_hash( Pedersen::hash_array(&[config_hash_version, chain_id, fee_token_address, native_fee_token_address]) } -pub fn get_bridge_init_configs(config: &ConfigFile) -> (Felt, Felt) { +pub fn get_bridge_init_configs(config: &Config) -> (Felt, Felt) { let program_hash = Felt::from_hex(config.sn_os_program_hash.as_str()).unwrap(); let config_hash = generate_config_hash( diff --git a/src/main.rs b/src/main.rs index 7500cd5..c93faab 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,6 +5,7 @@ mod setup_scripts; pub mod tests; pub mod utils; +use std::fs; use std::fs::File; use std::path::PathBuf; use std::str::FromStr; @@ -48,19 +49,84 @@ enum BootstrapMode { Braavos, } -#[derive(Parser, Debug)] +#[derive(Parser, Debug, Clone)] #[command(version, about, long_about = None)] pub struct CliArgs { - #[clap(long)] + #[clap(long, env)] config: Option, #[clap(long, env, value_enum)] mode: BootstrapMode, #[clap(long, env)] output_file: Option, + // Config overrides + #[clap(long, env)] + eth_rpc: Option, + #[clap(long, env)] + eth_priv_key: Option, + #[clap(long, env)] + rollup_seq_url: Option, + #[clap(long, env)] + rollup_priv_key: Option, + #[clap(long, env)] + eth_chain_id: Option, + #[clap(long, env)] + l1_deployer_address: Option, + #[clap(long, env)] + l1_wait_time: Option, + #[clap(long, env)] + sn_os_program_hash: Option, + #[clap(long, env)] + config_hash_version: Option, + #[clap(long, env)] + app_chain_id: Option, + #[clap(long, env)] + fee_token_address: Option, + #[clap(long, env)] + native_fee_token_address: Option, + #[clap(long, env)] + cross_chain_wait_time: Option, + #[clap(long, env)] + l1_multisig_address: Option, + #[clap(long, env)] + l2_multisig_address: Option, + #[clap(long, env)] + verifier_address: Option, + #[clap(long, env)] + operator_address: Option, + #[clap(long, env)] + dev: Option, + #[clap(long, env)] + core_contract_address: Option, + #[clap(long, env)] + core_contract_implementation_address: Option, } -#[derive(Serialize, Deserialize)] +#[derive(Serialize, Deserialize, Default)] pub struct ConfigFile { + pub eth_rpc: Option, + pub eth_priv_key: Option, + pub rollup_seq_url: Option, + pub rollup_priv_key: Option, + pub eth_chain_id: Option, + pub l1_deployer_address: Option, + pub l1_wait_time: Option, + pub sn_os_program_hash: Option, + pub config_hash_version: Option, + pub app_chain_id: Option, + pub fee_token_address: Option, + pub native_fee_token_address: Option, + pub cross_chain_wait_time: Option, + pub l1_multisig_address: Option, + pub l2_multisig_address: Option, + pub verifier_address: Option, + pub operator_address: Option, + pub dev: Option, + pub core_contract_address: Option, + pub core_contract_implementation_address: Option, +} + +#[derive(Serialize, Deserialize)] +pub struct Config { pub eth_rpc: String, pub eth_priv_key: String, pub rollup_seq_url: String, @@ -83,7 +149,7 @@ pub struct ConfigFile { pub core_contract_implementation_address: Option, } -impl Default for ConfigFile { +impl Default for Config { fn default() -> Self { Self { eth_rpc: "http://127.0.0.1:8545".to_string(), @@ -110,6 +176,148 @@ impl Default for ConfigFile { } } +impl Config { + fn new(args: CliArgs) -> Self { + // First load defaults + let mut config = Config::default(); + + // Then override with config file if present + if let Some(path) = args.config { + if let Ok(file_config) = Self::load_config_file(&path) { + if let Some(v) = file_config.eth_rpc { + config.eth_rpc = v; + } + if let Some(v) = file_config.eth_priv_key { + config.eth_priv_key = v; + } + if let Some(v) = file_config.rollup_seq_url { + config.rollup_seq_url = v; + } + if let Some(v) = file_config.rollup_priv_key { + config.rollup_priv_key = v; + } + if let Some(v) = file_config.eth_chain_id { + config.eth_chain_id = v; + } + if let Some(v) = file_config.l1_deployer_address { + config.l1_deployer_address = v; + } + if let Some(v) = file_config.l1_wait_time { + config.l1_wait_time = v; + } + if let Some(v) = file_config.sn_os_program_hash { + config.sn_os_program_hash = v; + } + if let Some(v) = file_config.config_hash_version { + config.config_hash_version = v; + } + if let Some(v) = file_config.app_chain_id { + config.app_chain_id = v; + } + if let Some(v) = file_config.fee_token_address { + config.fee_token_address = v; + } + if let Some(v) = file_config.native_fee_token_address { + config.native_fee_token_address = v; + } + if let Some(v) = file_config.cross_chain_wait_time { + config.cross_chain_wait_time = v; + } + if let Some(v) = file_config.l1_multisig_address { + config.l1_multisig_address = v; + } + if let Some(v) = file_config.l2_multisig_address { + config.l2_multisig_address = v; + } + if let Some(v) = file_config.verifier_address { + config.verifier_address = v; + } + if let Some(v) = file_config.operator_address { + config.operator_address = v; + } + if let Some(v) = file_config.dev { + config.dev = v; + } + if let Some(v) = file_config.core_contract_address { + config.core_contract_address = Some(v); + } + if let Some(v) = file_config.core_contract_implementation_address { + config.core_contract_implementation_address = Some(v); + } + } + } + + // Finally override with CLI args if present + if let Some(v) = args.eth_rpc { + config.eth_rpc = v; + } + if let Some(v) = args.eth_priv_key { + config.eth_priv_key = v; + } + if let Some(v) = args.rollup_seq_url { + config.rollup_seq_url = v; + } + if let Some(v) = args.rollup_priv_key { + config.rollup_priv_key = v; + } + if let Some(v) = args.eth_chain_id { + config.eth_chain_id = v; + } + if let Some(v) = args.l1_deployer_address { + config.l1_deployer_address = v; + } + if let Some(v) = args.l1_wait_time { + config.l1_wait_time = v; + } + if let Some(v) = args.sn_os_program_hash { + config.sn_os_program_hash = v; + } + if let Some(v) = args.config_hash_version { + config.config_hash_version = v; + } + if let Some(v) = args.app_chain_id { + config.app_chain_id = v; + } + if let Some(v) = args.fee_token_address { + config.fee_token_address = v; + } + if let Some(v) = args.native_fee_token_address { + config.native_fee_token_address = v; + } + if let Some(v) = args.cross_chain_wait_time { + config.cross_chain_wait_time = v; + } + if let Some(v) = args.l1_multisig_address { + config.l1_multisig_address = v; + } + if let Some(v) = args.l2_multisig_address { + config.l2_multisig_address = v; + } + if let Some(v) = args.verifier_address { + config.verifier_address = v; + } + if let Some(v) = args.operator_address { + config.operator_address = v; + } + if let Some(v) = args.dev { + config.dev = v; + } + if let Some(v) = args.core_contract_address { + config.core_contract_address = Some(v); + } + if let Some(v) = args.core_contract_implementation_address { + config.core_contract_implementation_address = Some(v); + } + + config + } + + fn load_config_file(path: &PathBuf) -> Result> { + let content = fs::read_to_string(path)?; + Ok(serde_json::from_str(&content)?) + } +} + #[tokio::main] pub async fn main() { env_logger::init(); @@ -119,20 +327,13 @@ pub async fn main() { println!("{color_red}{}{color_reset}", BANNER); - // Load config from file or use defaults - let config_file = match args.config { - Some(path) => { - let file = File::open(path).expect("Failed to open config file"); - serde_json::from_reader(file).expect("Failed to parse config file") - } - None => ConfigFile::default(), - }; + let config = Config::new(args.clone()); - let clients = Clients::init_from_config(&config_file).await; + let clients = Clients::init_from_config(&config).await; let output = match args.mode { BootstrapMode::Core | BootstrapMode::SetupL1 => { - let output = setup_core_contract(&config_file, &clients).await; + let output = setup_core_contract(&config, &clients).await; BootstrapperOutput { starknet_contract_address: Some(output.core_contract_client.address()), @@ -140,27 +341,27 @@ pub async fn main() { ..Default::default() } } - BootstrapMode::SetupL2 => setup_l2(&config_file, &clients).await, + BootstrapMode::SetupL2 => setup_l2(&config, &clients).await, BootstrapMode::EthBridge => { - let core_contract_client = get_core_contract_client(&config_file, &clients); - let output = setup_eth_bridge(None, &core_contract_client, &config_file, &clients).await; + let core_contract_client = get_core_contract_client(&config, &clients); + let output = setup_eth_bridge(None, &core_contract_client, &config, &clients).await; BootstrapperOutput { eth_bridge_setup_outputs: Some(output), ..Default::default() } } BootstrapMode::Erc20Bridge => { - let core_contract_client = get_core_contract_client(&config_file, &clients); - let output = setup_erc20_bridge(None, &core_contract_client, &config_file, &clients).await; + let core_contract_client = get_core_contract_client(&config, &clients); + let output = setup_erc20_bridge(None, &core_contract_client, &config, &clients).await; BootstrapperOutput { erc20_bridge_setup_outputs: Some(output), ..Default::default() } } BootstrapMode::Udc => { - let output = setup_udc(None, &config_file, &clients).await; + let output = setup_udc(None, &config, &clients).await; BootstrapperOutput { udc_setup_outputs: Some(output), ..Default::default() } } BootstrapMode::Argent => { - let output = setup_argent(None, &config_file, &clients).await; + let output = setup_argent(None, &config, &clients).await; BootstrapperOutput { argent_setup_outputs: Some(output), ..Default::default() } } BootstrapMode::Braavos => { - let output = setup_braavos(None, &config_file, &clients).await; + let output = setup_braavos(None, &config, &clients).await; BootstrapperOutput { braavos_setup_outputs: Some(output), ..Default::default() } } }; @@ -179,11 +380,11 @@ pub async fn main() { } } -fn get_core_contract_client(config_file: &ConfigFile, clients: &Clients) -> CoreContractStarknetL1Output { - let Some(core_contract_address) = config_file.core_contract_address.clone() else { +fn get_core_contract_client(config: &Config, clients: &Clients) -> CoreContractStarknetL1Output { + let Some(core_contract_address) = config.core_contract_address.clone() else { panic!("Core contract address is required for ETH bridge setup"); }; - let Some(core_contract_implementation_address) = config_file.core_contract_implementation_address.clone() else { + let Some(core_contract_implementation_address) = config.core_contract_implementation_address.clone() else { panic!("Core contract implementation address is required for ETH bridge setup"); }; let core_contract_client = StarknetValidityContractClient::new( @@ -194,9 +395,9 @@ fn get_core_contract_client(config_file: &ConfigFile, clients: &Clients) -> Core CoreContractStarknetL1Output { core_contract_client: Box::new(StarknetValidityContract { core_contract_client }) } } -async fn get_account<'a>(clients: &'a Clients, config_file: &'a ConfigFile) -> RpcAccount<'a> { +async fn get_account<'a>(clients: &'a Clients, config: &'a Config) -> RpcAccount<'a> { log::info!("⏳ L2 State and Initialisation Started"); - let account = account_init(clients, config_file).await; + let account = account_init(clients, config).await; log::info!("🔐 Account with given private key deployed on L2. [Account Address : {:?}]", account.address()); account } @@ -219,12 +420,12 @@ pub struct BootstrapperOutput { pub braavos_setup_outputs: Option, } -pub async fn bootstrap(config_file: &ConfigFile, clients: &Clients) -> BootstrapperOutput { +pub async fn bootstrap(config: &Config, clients: &Clients) -> BootstrapperOutput { // setup core contract (L1) - let core_contract_client = setup_core_contract(config_file, clients).await; + let core_contract_client = setup_core_contract(config, clients).await; // setup L2 - let l2_output = setup_l2(config_file, clients).await; + let l2_output = setup_l2(config, clients).await; BootstrapperOutput { starknet_contract_address: Some(core_contract_client.core_contract_client.address()), @@ -235,8 +436,8 @@ pub async fn bootstrap(config_file: &ConfigFile, clients: &Clients) -> Bootstrap } } -async fn setup_core_contract(config_file: &ConfigFile, clients: &Clients) -> CoreContractStarknetL1Output { - let core_contract = CoreContractStarknetL1::new(config_file, clients); +async fn setup_core_contract(config: &Config, clients: &Clients) -> CoreContractStarknetL1Output { + let core_contract = CoreContractStarknetL1::new(config, clients); let core_contract_client = core_contract.setup().await; log::info!("📦 Core address : {:?}", core_contract_client.core_contract_client.address()); log::info!( @@ -255,18 +456,18 @@ async fn setup_core_contract(config_file: &ConfigFile, clients: &Clients) -> Cor async fn setup_eth_bridge<'a>( account: Option>, core_contract_client: &CoreContractStarknetL1Output, - config_file: &ConfigFile, + config: &Config, clients: &Clients, ) -> EthBridgeSetupOutput { let account = match account { Some(account) => account, - None => get_account(clients, config_file).await, + None => get_account(clients, config).await, }; log::info!("⏳ Starting ETH bridge deployment"); let eth_bridge = EthBridge::new( account.clone(), account.address(), - config_file, + config, clients, core_contract_client.core_contract_client.as_ref(), ); @@ -278,18 +479,18 @@ async fn setup_eth_bridge<'a>( async fn setup_erc20_bridge<'a>( account: Option>, core_contract_client: &CoreContractStarknetL1Output, - config_file: &ConfigFile, + config: &Config, clients: &Clients, ) -> Erc20BridgeSetupOutput { let account = match account { Some(account) => account, - None => get_account(clients, config_file).await, + None => get_account(clients, config).await, }; log::info!("⏳ Starting ERC20 token bridge deployment"); let erc20_bridge = Erc20Bridge::new( account.clone(), account.address(), - config_file, + config, clients, core_contract_client.core_contract_client.as_ref(), ); @@ -298,13 +499,13 @@ async fn setup_erc20_bridge<'a>( erc20_bridge_setup_outputs } -async fn setup_udc<'a>(account: Option>, config_file: &ConfigFile, clients: &Clients) -> UdcSetupOutput { +async fn setup_udc<'a>(account: Option>, config: &Config, clients: &Clients) -> UdcSetupOutput { let account = match account { Some(account) => account, - None => get_account(clients, config_file).await, + None => get_account(clients, config).await, }; log::info!("⏳ Starting UDC (Universal Deployer Contract) deployment"); - let udc = UdcSetup::new(account.clone(), account.address(), config_file, clients); + let udc = UdcSetup::new(account.clone(), account.address(), config, clients); let udc_setup_outputs = udc.setup().await; log::info!( "*️⃣ UDC setup completed. [UDC Address : {:?}, UDC class hash : {:?}]", @@ -315,14 +516,10 @@ async fn setup_udc<'a>(account: Option>, config_file: &ConfigFile udc_setup_outputs } -async fn setup_argent<'a>( - account: Option>, - config_file: &ConfigFile, - clients: &Clients, -) -> ArgentSetupOutput { +async fn setup_argent<'a>(account: Option>, config: &Config, clients: &Clients) -> ArgentSetupOutput { let account = match account { Some(account) => account, - None => get_account(clients, config_file).await, + None => get_account(clients, config).await, }; log::info!("⏳ Starting Argent Account deployment"); let argent = ArgentSetup::new(account.clone()); @@ -332,17 +529,13 @@ async fn setup_argent<'a>( argent_setup_outputs } -async fn setup_braavos<'a>( - account: Option>, - config_file: &ConfigFile, - clients: &Clients, -) -> BraavosSetupOutput { +async fn setup_braavos<'a>(account: Option>, config: &Config, clients: &Clients) -> BraavosSetupOutput { let account = match account { Some(account) => account, - None => get_account(clients, config_file).await, + None => get_account(clients, config).await, }; log::info!("⏳ Starting Braavos Account deployment"); - let braavos = BraavosSetup::new(account.clone(), config_file, clients); + let braavos = BraavosSetup::new(account.clone(), config, clients); let braavos_setup_outputs = braavos.setup().await; log::info!( "*️⃣ Braavos setup completed. [Braavos account class hash : {:?}]", @@ -352,27 +545,27 @@ async fn setup_braavos<'a>( braavos_setup_outputs } -pub async fn setup_l2(config_file: &ConfigFile, clients: &Clients) -> BootstrapperOutput { - let account = get_account(clients, config_file).await; +pub async fn setup_l2(config: &Config, clients: &Clients) -> BootstrapperOutput { + let account = get_account(clients, config).await; - let core_contract_client = get_core_contract_client(config_file, clients); + let core_contract_client = get_core_contract_client(config, clients); // setup eth bridge let eth_bridge_setup_outputs = - setup_eth_bridge(Some(account.clone()), &core_contract_client, config_file, clients).await; + setup_eth_bridge(Some(account.clone()), &core_contract_client, config, clients).await; // setup erc20 bridge let erc20_bridge_setup_outputs = - setup_erc20_bridge(Some(account.clone()), &core_contract_client, config_file, clients).await; + setup_erc20_bridge(Some(account.clone()), &core_contract_client, config, clients).await; // setup udc - let udc_setup_outputs = setup_udc(Some(account.clone()), config_file, clients).await; + let udc_setup_outputs = setup_udc(Some(account.clone()), config, clients).await; // setup argent account - let argent_setup_outputs = setup_argent(Some(account.clone()), config_file, clients).await; + let argent_setup_outputs = setup_argent(Some(account.clone()), config, clients).await; // setup braavos account - let braavos_setup_outputs = setup_braavos(Some(account.clone()), config_file, clients).await; + let braavos_setup_outputs = setup_braavos(Some(account.clone()), config, clients).await; BootstrapperOutput { eth_bridge_setup_outputs: Some(eth_bridge_setup_outputs), diff --git a/src/setup_scripts/account_setup.rs b/src/setup_scripts/account_setup.rs index 9bb9bfd..790be99 100644 --- a/src/setup_scripts/account_setup.rs +++ b/src/setup_scripts/account_setup.rs @@ -9,9 +9,9 @@ use crate::contract_clients::utils::{ }; use crate::utils::constants::{OZ_ACCOUNT_CASM_PATH, OZ_ACCOUNT_PATH, OZ_ACCOUNT_SIERRA_PATH}; use crate::utils::{convert_to_hex, save_to_json, JsonValueType}; -use crate::ConfigFile; +use crate::Config; -pub async fn account_init<'a>(clients: &'a Clients, arg_config: &'a ConfigFile) -> RpcAccount<'a> { +pub async fn account_init<'a>(clients: &'a Clients, arg_config: &'a Config) -> RpcAccount<'a> { // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> // Making temp account for declaration of OZ account Cairo 1 contract let oz_account_class_hash = declare_contract(DeclarationInput::LegacyDeclarationInputs( diff --git a/src/setup_scripts/braavos.rs b/src/setup_scripts/braavos.rs index d747792..437756a 100644 --- a/src/setup_scripts/braavos.rs +++ b/src/setup_scripts/braavos.rs @@ -13,11 +13,11 @@ use crate::utils::constants::{ BRAAVOS_BASE_ACCOUNT_SIERRA_PATH, }; use crate::utils::{save_to_json, wait_for_transaction, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub struct BraavosSetup<'a> { account: RpcAccount<'a>, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, } @@ -27,7 +27,7 @@ pub struct BraavosSetupOutput { } impl<'a> BraavosSetup<'a> { - pub fn new(account: RpcAccount<'a>, arg_config: &'a ConfigFile, clients: &'a Clients) -> Self { + pub fn new(account: RpcAccount<'a>, arg_config: &'a Config, clients: &'a Clients) -> Self { Self { account, arg_config, clients } } diff --git a/src/setup_scripts/core_contract.rs b/src/setup_scripts/core_contract.rs index 62dc17d..8398460 100644 --- a/src/setup_scripts/core_contract.rs +++ b/src/setup_scripts/core_contract.rs @@ -8,10 +8,10 @@ use crate::contract_clients::starknet_sovereign::StarknetSovereignContract; use crate::contract_clients::starknet_validity::StarknetValidityContract; use crate::contract_clients::utils::get_bridge_init_configs; use crate::utils::{save_to_json, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub struct CoreContractStarknetL1<'a> { - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, } @@ -20,7 +20,7 @@ pub struct CoreContractStarknetL1Output { } impl<'a> CoreContractStarknetL1<'a> { - pub fn new(arg_config: &'a ConfigFile, clients: &'a Clients) -> Self { + pub fn new(arg_config: &'a Config, clients: &'a Clients) -> Self { Self { arg_config, clients } } diff --git a/src/setup_scripts/erc20_bridge.rs b/src/setup_scripts/erc20_bridge.rs index db313ce..0435b41 100644 --- a/src/setup_scripts/erc20_bridge.rs +++ b/src/setup_scripts/erc20_bridge.rs @@ -18,12 +18,12 @@ use crate::contract_clients::token_bridge::StarknetTokenBridge; use crate::contract_clients::utils::{build_single_owner_account, declare_contract, DeclarationInput, RpcAccount}; use crate::utils::constants::{ERC20_CASM_PATH, ERC20_SIERRA_PATH}; use crate::utils::{convert_to_hex, save_to_json, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub struct Erc20Bridge<'a> { account: RpcAccount<'a>, account_address: Felt, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, core_contract: &'a dyn CoreContract, } @@ -44,7 +44,7 @@ impl<'a> Erc20Bridge<'a> { pub fn new( account: RpcAccount<'a>, account_address: Felt, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, core_contract: &'a dyn CoreContract, ) -> Self { diff --git a/src/setup_scripts/eth_bridge.rs b/src/setup_scripts/eth_bridge.rs index 8c95762..5568304 100644 --- a/src/setup_scripts/eth_bridge.rs +++ b/src/setup_scripts/eth_bridge.rs @@ -19,12 +19,12 @@ use crate::contract_clients::utils::{ use crate::helpers::account_actions::{get_contract_address_from_deploy_tx, AccountActions}; use crate::utils::constants::{ERC20_LEGACY_PATH, LEGACY_BRIDGE_PATH, PROXY_LEGACY_PATH, STARKGATE_PROXY_PATH}; use crate::utils::{convert_to_hex, invoke_contract, save_to_json, wait_for_transaction, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub struct EthBridge<'a> { account: RpcAccount<'a>, account_address: Felt, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, core_contract: &'a dyn CoreContract, } @@ -46,7 +46,7 @@ impl<'a> EthBridge<'a> { pub fn new( account: RpcAccount<'a>, account_address: Felt, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, core_contract: &'a dyn CoreContract, ) -> Self { diff --git a/src/setup_scripts/udc.rs b/src/setup_scripts/udc.rs index 0773c9a..f3641be 100644 --- a/src/setup_scripts/udc.rs +++ b/src/setup_scripts/udc.rs @@ -10,12 +10,12 @@ use crate::contract_clients::utils::{declare_contract, DeclarationInput, RpcAcco use crate::helpers::account_actions::{get_contract_address_from_deploy_tx, AccountActions}; use crate::utils::constants::UDC_PATH; use crate::utils::{save_to_json, wait_for_transaction, JsonValueType}; -use crate::ConfigFile; +use crate::Config; pub struct UdcSetup<'a> { account: RpcAccount<'a>, account_address: Felt, - arg_config: &'a ConfigFile, + arg_config: &'a Config, clients: &'a Clients, } @@ -26,12 +26,7 @@ pub struct UdcSetupOutput { } impl<'a> UdcSetup<'a> { - pub fn new( - account: RpcAccount<'a>, - account_address: Felt, - arg_config: &'a ConfigFile, - clients: &'a Clients, - ) -> Self { + pub fn new(account: RpcAccount<'a>, account_address: Felt, arg_config: &'a Config, clients: &'a Clients) -> Self { Self { account, account_address, arg_config, clients } } diff --git a/src/tests/erc20_bridge.rs b/src/tests/erc20_bridge.rs index de00372..54ff2d8 100644 --- a/src/tests/erc20_bridge.rs +++ b/src/tests/erc20_bridge.rs @@ -9,12 +9,12 @@ use crate::contract_clients::config::Clients; use crate::contract_clients::token_bridge::StarknetTokenBridge; use crate::contract_clients::utils::read_erc20_balance; use crate::tests::constants::L2_DEPLOYER_ADDRESS; -use crate::ConfigFile; +use crate::Config; // TODO : Uncomment L2 --> L1 part after this part is added in the madara-orchestrator. pub async fn erc20_bridge_test_helper( clients: &Clients, - arg_config: &ConfigFile, + arg_config: &Config, l2_erc20_token_address: Felt, token_bridge: StarknetTokenBridge, _l2_bridge_address: Felt, diff --git a/src/tests/eth_bridge.rs b/src/tests/eth_bridge.rs index 6f6ae1c..6efbc9d 100644 --- a/src/tests/eth_bridge.rs +++ b/src/tests/eth_bridge.rs @@ -9,12 +9,12 @@ use crate::contract_clients::config::Clients; use crate::contract_clients::eth_bridge::StarknetLegacyEthBridge; use crate::contract_clients::utils::read_erc20_balance; use crate::tests::constants::L2_DEPLOYER_ADDRESS; -use crate::ConfigFile; +use crate::Config; // TODO : Uncomment L2 --> L1 part after this part is added in the madara-orchestrator. pub async fn eth_bridge_test_helper( clients: &Clients, - arg_config: &ConfigFile, + arg_config: &Config, l2_eth_address: Felt, _l2_bridge_address: Felt, eth_bridge: StarknetLegacyEthBridge, diff --git a/src/tests/mod.rs b/src/tests/mod.rs index 7cb71d1..479e0dd 100644 --- a/src/tests/mod.rs +++ b/src/tests/mod.rs @@ -9,9 +9,9 @@ use crate::contract_clients::config::Clients; use crate::tests::erc20_bridge::erc20_bridge_test_helper; use crate::tests::eth_bridge::eth_bridge_test_helper; use crate::tests::madara::{MadaraCmd, MadaraCmdBuilder}; -use crate::{bootstrap, setup_core_contract, setup_l2, BootstrapperOutput, ConfigFile}; +use crate::{bootstrap, setup_core_contract, setup_l2, BootstrapperOutput, Config}; -async fn test_setup(args: &ConfigFile, clients: &Clients) -> (BootstrapperOutput, MadaraCmd) { +async fn test_setup(args: &Config, clients: &Clients) -> (BootstrapperOutput, MadaraCmd) { // Setup L1 (core contract) let core_contract_client = setup_core_contract(args, clients).await; @@ -19,7 +19,7 @@ async fn test_setup(args: &ConfigFile, clients: &Clients) -> (BootstrapperOutput let core_contract_implementation_address = core_contract_client.core_contract_client.implementation_address(); // Create a new config with the core contract addresses - let mut config = get_test_config_file(); + let mut config = get_test_config(); config.core_contract_address = Some(format!("{:?}", core_contract_address)); config.core_contract_implementation_address = Some(format!("{:?}", core_contract_implementation_address)); @@ -67,7 +67,7 @@ async fn test_setup(args: &ConfigFile, clients: &Clients) -> (BootstrapperOutput #[ignore = "ignored because we have a e2e test, and this is for a local test"] async fn deploy_bridge() -> Result<(), anyhow::Error> { env_logger::init(); - let config = get_test_config_file(); + let config = get_test_config(); let clients = Clients::init_from_config(&config).await; bootstrap(&config, &clients).await; @@ -79,7 +79,7 @@ async fn deploy_bridge() -> Result<(), anyhow::Error> { #[ignore = "ignored because we have a e2e test, and this is for a local test"] async fn deposit_and_withdraw_eth_bridge() -> Result<(), anyhow::Error> { env_logger::init(); - let config = get_test_config_file(); + let config = get_test_config(); let clients = Clients::init_from_config(&config).await; let out = bootstrap(&config, &clients).await; let eth_bridge_setup = out.eth_bridge_setup_outputs.unwrap(); @@ -101,7 +101,7 @@ async fn deposit_and_withdraw_eth_bridge() -> Result<(), anyhow::Error> { #[ignore = "ignored because we have a e2e test, and this is for a local test"] async fn deposit_and_withdraw_erc20_bridge() -> Result<(), anyhow::Error> { env_logger::init(); - let config = get_test_config_file(); + let config = get_test_config(); let clients = Clients::init_from_config(&config).await; let out = bootstrap(&config, &clients).await; let eth_token_setup = out.erc20_bridge_setup_outputs.unwrap(); @@ -122,7 +122,7 @@ async fn deposit_and_withdraw_erc20_bridge() -> Result<(), anyhow::Error> { #[tokio::test] async fn deposit_tests_both_bridges() -> Result<(), anyhow::Error> { env_logger::init(); - let config = get_test_config_file(); + let config = get_test_config(); let clients = Clients::init_from_config(&config).await; let (out, _madara) = test_setup(&config, &clients).await; @@ -150,6 +150,6 @@ async fn deposit_tests_both_bridges() -> Result<(), anyhow::Error> { Ok(()) } -fn get_test_config_file() -> ConfigFile { - ConfigFile::default() +fn get_test_config() -> Config { + Config::default() }