14116412372

Committed 27 Mar 2025 08:47PM UTC coverage: 77.183% (-0.009%) from 77.192%

Build # 14116412372

Build Type

Pull #26

github

Committed by

web-flow

Commit Message

Merge 62bb60c7e into 787e328dd

Pull Request Pull Request #26: Fixes

Coverage Stats

21 of 22 new or added lines in 6 files covered. (95.45%)

6 existing lines in 2 files now uncovered.

2077 of 2691 relevant lines covered (77.18%)

6.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.82

/src/setup_scripts/erc20_bridge.rs

use std::str::FromStr;
use std::time::Duration;

use ethers::abi::Address;
use ethers::prelude::{H160, U256};
use serde::Serialize;
use starknet::core::types::Felt;
use starknet_core::types::{BlockId, BlockTag, FunctionCall};
use starknet_core::utils::get_selector_from_name;
use starknet_providers::jsonrpc::HttpTransport;
use starknet_providers::{JsonRpcClient, Provider};
use tokio::time::sleep;

use crate::contract_clients::config::Clients;
use crate::contract_clients::core_contract::CoreContract;
use crate::contract_clients::eth_bridge::BridgeDeployable;
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, hexstring_to_address, save_to_json, JsonValueType};
use crate::ConfigFile;

pub struct Erc20Bridge<'a> {
    account: RpcAccount<'a>,
    account_address: Felt,
    arg_config: &'a ConfigFile,
    clients: &'a Clients,
    core_contract: &'a dyn CoreContract,
}

#[derive(Serialize, Clone)]
pub struct Erc20BridgeSetupOutput {
    pub erc20_cairo_one_class_hash: Felt,
    pub l1_token_bridge_proxy: Address,
    pub l1_manager_address: Address,
    pub l1_registry_address: Address,
    pub l2_token_bridge: Felt,
    pub test_erc20_token_address: Felt,
    #[serde(skip)]
    pub token_bridge: StarknetTokenBridge,
}

impl<'a> Erc20Bridge<'a> {
    pub fn new(
        account: RpcAccount<'a>,
        account_address: Felt,
        arg_config: &'a ConfigFile,
        clients: &'a Clients,
        core_contract: &'a dyn CoreContract,
    ) -> Self {
        Self { account, account_address, arg_config, clients, core_contract }
    }

    pub async fn setup(&self) -> Erc20BridgeSetupOutput {
        let erc20_cairo_one_class_hash = declare_contract(DeclarationInput::DeclarationInputs(
            String::from(ERC20_SIERRA_PATH),
            String::from(ERC20_CASM_PATH),
            self.account.clone(),
        ))
        .await;
        log::info!("🌗 ERC20 Class Hash declared : {:?}", erc20_cairo_one_class_hash);
        save_to_json("erc20_cairo_one_class_hash", &JsonValueType::StringType(erc20_cairo_one_class_hash.to_string()))
            .unwrap();
        sleep(Duration::from_secs(10)).await;

        let token_bridge = StarknetTokenBridge::deploy(self.core_contract.client().clone(), self.arg_config.dev).await;

        log::info!(
            "❇️ ERC20 Token Bridge L1 deployment completed [ERC20 Token Bridge Address (L1) : {:?}]",
            token_bridge.bridge_address()
        );
        save_to_json("ERC20_l1_bridge_address", &JsonValueType::EthAddress(token_bridge.bridge_address())).unwrap();
        save_to_json("ERC20_l1_registry_address", &JsonValueType::EthAddress(token_bridge.registry_address())).unwrap();
        save_to_json("ERC20_l1_manager_address", &JsonValueType::EthAddress(token_bridge.manager_address())).unwrap();

        let l2_bridge_address = StarknetTokenBridge::deploy_l2_contracts(
            self.clients.provider_l2(),
            &self.arg_config.rollup_priv_key,
            &convert_to_hex(&self.account_address.to_string()),
        )
        .await;

        log::info!(
            "❇️ ERC20 Token Bridge L2 deployment completed [ERC20 Token Bridge Address (L2) : {:?}]",
            l2_bridge_address
        );
        save_to_json("ERC20_l2_bridge_address", &JsonValueType::StringType(l2_bridge_address.to_string())).unwrap();

        let provider_l2 = self.clients.provider_l2();
        let account = build_single_owner_account(
            provider_l2,
            &self.arg_config.rollup_priv_key,
            &convert_to_hex(&self.account_address.to_string()),
            false,
        )
        .await;

        if self.arg_config.dev {
            token_bridge
                .initialize(self.core_contract.address(), hexstring_to_address(&self.arg_config.l1_deployer_address))
                .await;
        } else {
            token_bridge
                .setup_permissions_with_bridge_l1(
                    hexstring_to_address(&self.arg_config.l1_deployer_address),
                    hexstring_to_address(&self.arg_config.l1_multisig_address),
                )
                .await;
            token_bridge.add_implementation_token_bridge(self.core_contract.address()).await;
            token_bridge.upgrade_to_token_bridge(self.core_contract.address()).await;
        }

        token_bridge
            .setup_l2_bridge(
                self.clients.provider_l2(),
                l2_bridge_address,
                &convert_to_hex(&self.account_address.to_string()),
                &account,
                erc20_cairo_one_class_hash,
            )
            .await;
        token_bridge.setup_l1_bridge(U256::from_dec_str("100000000000000").unwrap(), l2_bridge_address).await;
        log::info!("❇️ Temp test token deployed on L1.");
        log::info!(
            "❇️ Waiting for temp test token to be deployed on L2 [⏳....] Approx. time : {:?} secs.",
            self.arg_config.cross_chain_wait_time + 10_u64
        );
        sleep(Duration::from_secs(self.arg_config.l1_wait_time.parse().unwrap())).await;
        // We need to wait a little bit more for message to be consumed and executed
        sleep(Duration::from_secs(self.arg_config.cross_chain_wait_time)).await;

        let l2_erc20_token_address =
            get_l2_token_address(self.clients.provider_l2(), &l2_bridge_address, &token_bridge.address()).await;
        log::info!(
            "❇️ L2 ERC20 Token Address deployed for testing [ ERC20 Test Token Address : {:?}]",
            l2_erc20_token_address
        );
        save_to_json(
            "ERC20_l2_token_address_temp_test",
            &JsonValueType::StringType(l2_erc20_token_address.to_string()),
        )
        .unwrap();

        Erc20BridgeSetupOutput {
            erc20_cairo_one_class_hash,
            l1_manager_address: token_bridge.manager_address(),
            l1_registry_address: token_bridge.registry_address(),
            l1_token_bridge_proxy: token_bridge.bridge_address(),
            l2_token_bridge: l2_bridge_address,
            test_erc20_token_address: l2_erc20_token_address,
            token_bridge,
        }
    }
}

async fn get_l2_token_address(
    rpc_provider_l2: &JsonRpcClient<HttpTransport>,
    l2_bridge_address: &Felt,
    l1_erc_20_address: &H160,
) -> Felt {
    rpc_provider_l2
        .call(
            FunctionCall {
                contract_address: *l2_bridge_address,
                entry_point_selector: get_selector_from_name("get_l2_token").unwrap(),
                calldata: vec![Felt::from_bytes_be_slice(l1_erc_20_address.as_bytes())],
            },
            BlockId::Tag(BlockTag::Pending),
        )
        .await
        .unwrap()[0]
}

1	use std::str::FromStr;
2	use std::time::Duration;
3
4	use ethers::abi::Address;
5	use ethers::prelude::{H160, U256};
6	use serde::Serialize;
7	use starknet::core::types::Felt;
8	use starknet_core::types::{BlockId, BlockTag, FunctionCall};
9	use starknet_core::utils::get_selector_from_name;
10	use starknet_providers::jsonrpc::HttpTransport;
11	use starknet_providers::{JsonRpcClient, Provider};
12	use tokio::time::sleep;
13
14	use crate::contract_clients::config::Clients;
15	use crate::contract_clients::core_contract::CoreContract;
16	use crate::contract_clients::eth_bridge::BridgeDeployable;
17	use crate::contract_clients::token_bridge::StarknetTokenBridge;
18	use crate::contract_clients::utils::{build_single_owner_account, declare_contract, DeclarationInput, RpcAccount};
19	use crate::utils::constants::{ERC20_CASM_PATH, ERC20_SIERRA_PATH};
20	use crate::utils::{convert_to_hex, hexstring_to_address, save_to_json, JsonValueType};
21	use crate::ConfigFile;
22
23	pub struct Erc20Bridge<'a> {
24	account: RpcAccount<'a>,
25	account_address: Felt,
26	arg_config: &'a ConfigFile,
27	clients: &'a Clients,
28	core_contract: &'a dyn CoreContract,
29	}
30
31	#[derive(Serialize, Clone)]
32	pub struct Erc20BridgeSetupOutput {
33	pub erc20_cairo_one_class_hash: Felt,
34	pub l1_token_bridge_proxy: Address,
35	pub l1_manager_address: Address,
36	pub l1_registry_address: Address,
37	pub l2_token_bridge: Felt,
38	pub test_erc20_token_address: Felt,
39	#[serde(skip)]
40	pub token_bridge: StarknetTokenBridge,
41	}
42
43	impl<'a> Erc20Bridge<'a> {
44	pub fn new(	1✔
45	account: RpcAccount<'a>,	1✔
46	account_address: Felt,	1✔
47	arg_config: &'a ConfigFile,	1✔
48	clients: &'a Clients,	1✔
49	core_contract: &'a dyn CoreContract,	1✔
50	) -> Self {	1✔
51	Self { account, account_address, arg_config, clients, core_contract }	1✔
52	}	1✔
53
54	pub async fn setup(&self) -> Erc20BridgeSetupOutput {	1✔
55	let erc20_cairo_one_class_hash = declare_contract(DeclarationInput::DeclarationInputs(	1✔
56	String::from(ERC20_SIERRA_PATH),	1✔
57	String::from(ERC20_CASM_PATH),	1✔
58	self.account.clone(),	1✔
59	))	1✔
60	.await;	4✔
61	log::info!("🌗 ERC20 Class Hash declared : {:?}", erc20_cairo_one_class_hash);	1✔
62	save_to_json("erc20_cairo_one_class_hash", &JsonValueType::StringType(erc20_cairo_one_class_hash.to_string()))	1✔
63	.unwrap();	1✔
64	sleep(Duration::from_secs(10)).await;	1✔
65
66	let token_bridge = StarknetTokenBridge::deploy(self.core_contract.client().clone(), self.arg_config.dev).await;	83✔
67
68	log::info!(	1✔
69	"❇️ ERC20 Token Bridge L1 deployment completed [ERC20 Token Bridge Address (L1) : {:?}]",	×
UNCOV 70	token_bridge.bridge_address()	×
71	);
72	save_to_json("ERC20_l1_bridge_address", &JsonValueType::EthAddress(token_bridge.bridge_address())).unwrap();	1✔
73	save_to_json("ERC20_l1_registry_address", &JsonValueType::EthAddress(token_bridge.registry_address())).unwrap();	1✔
74	save_to_json("ERC20_l1_manager_address", &JsonValueType::EthAddress(token_bridge.manager_address())).unwrap();	1✔
75
76	let l2_bridge_address = StarknetTokenBridge::deploy_l2_contracts(	1✔
77	self.clients.provider_l2(),	1✔
78	&self.arg_config.rollup_priv_key,	1✔
79	&convert_to_hex(&self.account_address.to_string()),	1✔
80	)	1✔
81	.await;	21✔
82
83	log::info!(	1✔
UNCOV 84	"❇️ ERC20 Token Bridge L2 deployment completed [ERC20 Token Bridge Address (L2) : {:?}]",	×
85	l2_bridge_address
86	);
87	save_to_json("ERC20_l2_bridge_address", &JsonValueType::StringType(l2_bridge_address.to_string())).unwrap();	1✔
88		1✔
89	let provider_l2 = self.clients.provider_l2();	1✔
90	let account = build_single_owner_account(	1✔
91	provider_l2,	1✔
92	&self.arg_config.rollup_priv_key,	1✔
93	&convert_to_hex(&self.account_address.to_string()),	1✔
94	false,	1✔
95	)	1✔
96	.await;	1✔
97
98	if self.arg_config.dev {	1✔
NEW 99	token_bridge	×
100	.initialize(self.core_contract.address(), hexstring_to_address(&self.arg_config.l1_deployer_address))	×
UNCOV 101	.await;	×
102	} else {
103	token_bridge	1✔
104	.setup_permissions_with_bridge_l1(	1✔
105	hexstring_to_address(&self.arg_config.l1_deployer_address),	1✔
106	hexstring_to_address(&self.arg_config.l1_multisig_address),	1✔
107	)	1✔
108	.await;	187✔
109	token_bridge.add_implementation_token_bridge(self.core_contract.address()).await;	33✔
110	token_bridge.upgrade_to_token_bridge(self.core_contract.address()).await;	33✔
111	}
112
113	token_bridge	1✔
114	.setup_l2_bridge(	1✔
115	self.clients.provider_l2(),	1✔
116	l2_bridge_address,	1✔
117	&convert_to_hex(&self.account_address.to_string()),	1✔
118	&account,	1✔
119	erc20_cairo_one_class_hash,	1✔
120	)	1✔
121	.await;	84✔
122	token_bridge.setup_l1_bridge(U256::from_dec_str("100000000000000").unwrap(), l2_bridge_address).await;	22✔
123	log::info!("❇️ Temp test token deployed on L1.");	1✔
124	log::info!(	1✔
125	"❇️ Waiting for temp test token to be deployed on L2 [⏳....] Approx. time : {:?} secs.",	×
UNCOV 126	self.arg_config.cross_chain_wait_time + 10_u64	×
127	);
128	sleep(Duration::from_secs(self.arg_config.l1_wait_time.parse().unwrap())).await;	1✔
129	// We need to wait a little bit more for message to be consumed and executed
130	sleep(Duration::from_secs(self.arg_config.cross_chain_wait_time)).await;	1✔
131
132	let l2_erc20_token_address =	1✔
133	get_l2_token_address(self.clients.provider_l2(), &l2_bridge_address, &token_bridge.address()).await;	1✔
134	log::info!(	1✔
UNCOV 135	"❇️ L2 ERC20 Token Address deployed for testing [ ERC20 Test Token Address : {:?}]",	×
136	l2_erc20_token_address
137	);
138	save_to_json(	1✔
139	"ERC20_l2_token_address_temp_test",	1✔
140	&JsonValueType::StringType(l2_erc20_token_address.to_string()),	1✔
141	)	1✔
142	.unwrap();	1✔
143		1✔
144	Erc20BridgeSetupOutput {	1✔
145	erc20_cairo_one_class_hash,	1✔
146	l1_manager_address: token_bridge.manager_address(),	1✔
147	l1_registry_address: token_bridge.registry_address(),	1✔
148	l1_token_bridge_proxy: token_bridge.bridge_address(),	1✔
149	l2_token_bridge: l2_bridge_address,	1✔
150	test_erc20_token_address: l2_erc20_token_address,	1✔
151	token_bridge,	1✔
152	}	1✔
153	}	1✔
154	}
155
156	async fn get_l2_token_address(	1✔
157	rpc_provider_l2: &JsonRpcClient<HttpTransport>,	1✔
158	l2_bridge_address: &Felt,	1✔
159	l1_erc_20_address: &H160,	1✔
160	) -> Felt {	1✔
161	rpc_provider_l2	1✔
162	.call(	1✔
163	FunctionCall {	1✔
164	contract_address: *l2_bridge_address,	1✔
165	entry_point_selector: get_selector_from_name("get_l2_token").unwrap(),	1✔
166	calldata: vec![Felt::from_bytes_be_slice(l1_erc_20_address.as_bytes())],	1✔
167	},	1✔
168	BlockId::Tag(BlockTag::Pending),	1✔
169	)	1✔
170	.await	1✔
171	.unwrap()[0]	1✔
172	}	1✔

madara-alliance / madara-bootstrapper / 14116412372

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous