diff --git a/Cargo.lock b/Cargo.lock index d0fe21b5..6de51bd6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -153,10 +153,13 @@ dependencies = [ name = "bridged-tokens-wrapper" version = "0.0.0" dependencies = [ + "eth-address", "multiversx-sc", "multiversx-sc-modules", "multiversx-sc-scenario", + "token-module", "transaction", + "tx-batch-module", ] [[package]] diff --git a/bridge-proxy/src/bridge-proxy.rs b/bridge-proxy/src/bridge-proxy.rs index 74286040..52af3e32 100644 --- a/bridge-proxy/src/bridge-proxy.rs +++ b/bridge-proxy/src/bridge-proxy.rs @@ -3,10 +3,12 @@ use multiversx_sc::imports::*; pub mod bridge_proxy_contract_proxy; pub mod config; -pub mod esdt_safe_proxy; +pub mod bridged_tokens_wrapper; use transaction::EthTransaction; +const DEFAULT_GAS_LIMIT_FOR_REFUND_CALLBACK: u64 = 20000000; // 20 million + #[multiversx_sc::contract] pub trait BridgeProxyContract: config::ConfigModule + multiversx_sc_modules::pause::PauseModule @@ -28,17 +30,20 @@ pub trait BridgeProxyContract: fn deposit(&self, eth_tx: EthTransaction) { self.require_not_paused(); let caller = self.blockchain().get_caller(); + let payment = self.call_value().single_esdt(); require!( caller == self.multi_transfer_address().get(), "Only MultiTransfer can do deposits" ); - self.pending_transactions().push(ð_tx); + let tx_id = self.pending_transactions().push(ð_tx); + self.payments(tx_id).set(&payment); } #[endpoint(execute)] fn execute(&self, tx_id: usize) { self.require_not_paused(); let tx = self.get_pending_transaction_by_id(tx_id); + let payment = self.payments(tx_id).get(); require!(tx.call_data.is_some(), "There is no data for a SC call!"); @@ -46,10 +51,11 @@ pub trait BridgeProxyContract: self.send() .contract_call::(tx.to.clone(), call_data.endpoint.clone()) .with_raw_arguments(call_data.args.clone().into()) - .with_esdt_transfer((tx.token_id.clone(), 0, tx.amount.clone())) + .with_esdt_transfer(payment) .with_gas_limit(call_data.gas_limit) .async_call_promise() .with_callback(self.callbacks().execution_callback(tx_id)) + .with_extra_gas_for_callback(DEFAULT_GAS_LIMIT_FOR_REFUND_CALLBACK) .register_promise(); } @@ -67,13 +73,14 @@ pub trait BridgeProxyContract: fn refund_transaction(&self, tx_id: usize) { let tx = self.get_pending_transaction_by_id(tx_id); - let esdt_safe_addr = self.esdt_safe_address().get(); + let payment = self.payments(tx_id).get(); + let esdt_safe_addr = self.bridged_tokens_wrapper_address().get(); self.tx() .to(esdt_safe_addr) - .typed(esdt_safe_proxy::EsdtSafeProxy) - .create_transaction(tx.from) - .single_esdt(&tx.token_id, 0, &tx.amount) + .typed(bridged_tokens_wrapper::BridgedTokensWrapperProxy) + .unwrap_token_create_transaction(&tx.token_id, tx.from) + .single_esdt(&payment.token_identifier, payment.token_nonce, &payment.amount) .sync_call(); } diff --git a/bridge-proxy/src/bridged_tokens_wrapper.rs b/bridge-proxy/src/bridged_tokens_wrapper.rs new file mode 100644 index 00000000..fbfdbaaa --- /dev/null +++ b/bridge-proxy/src/bridged_tokens_wrapper.rs @@ -0,0 +1,295 @@ +// Code generated by the multiversx-sc proxy generator. DO NOT EDIT. + +//////////////////////////////////////////////////// +////////////////// AUTO-GENERATED ////////////////// +//////////////////////////////////////////////////// + +#![allow(dead_code)] +#![allow(clippy::all)] + +use multiversx_sc::proxy_imports::*; + +pub struct BridgedTokensWrapperProxy; + +impl TxProxyTrait for BridgedTokensWrapperProxy +where + Env: TxEnv, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + type TxProxyMethods = BridgedTokensWrapperProxyMethods; + + fn proxy_methods(self, tx: Tx) -> Self::TxProxyMethods { + BridgedTokensWrapperProxyMethods { wrapped_tx: tx } + } +} + +pub struct BridgedTokensWrapperProxyMethods +where + Env: TxEnv, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + wrapped_tx: Tx, +} + +#[rustfmt::skip] +impl BridgedTokensWrapperProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + Gas: TxGas, +{ + pub fn init( + self, + ) -> TxTypedDeploy { + self.wrapped_tx + .payment(NotPayable) + .raw_deploy() + .original_result() + } +} + +#[rustfmt::skip] +impl BridgedTokensWrapperProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + pub fn upgrade( + self, + ) -> TxTypedUpgrade { + self.wrapped_tx + .payment(NotPayable) + .raw_upgrade() + .original_result() + } +} + +#[rustfmt::skip] +impl BridgedTokensWrapperProxyMethods +where + Env: TxEnv, + Env::Api: VMApi, + From: TxFrom, + To: TxTo, + Gas: TxGas, +{ + pub fn add_wrapped_token< + Arg0: ProxyArg>, + Arg1: ProxyArg, + >( + self, + universal_bridged_token_ids: Arg0, + num_decimals: Arg1, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("addWrappedToken") + .argument(&universal_bridged_token_ids) + .argument(&num_decimals) + .original_result() + } + + pub fn update_wrapped_token< + Arg0: ProxyArg>, + Arg1: ProxyArg, + >( + self, + universal_bridged_token_ids: Arg0, + num_decimals: Arg1, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("updateWrappedToken") + .argument(&universal_bridged_token_ids) + .argument(&num_decimals) + .original_result() + } + + pub fn remove_wrapped_token< + Arg0: ProxyArg>, + >( + self, + universal_bridged_token_ids: Arg0, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("removeWrappedToken") + .argument(&universal_bridged_token_ids) + .original_result() + } + + pub fn whitelist_token< + Arg0: ProxyArg>, + Arg1: ProxyArg, + Arg2: ProxyArg>, + >( + self, + chain_specific_token_id: Arg0, + chain_specific_token_decimals: Arg1, + universal_bridged_token_ids: Arg2, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("whitelistToken") + .argument(&chain_specific_token_id) + .argument(&chain_specific_token_decimals) + .argument(&universal_bridged_token_ids) + .original_result() + } + + pub fn update_whitelisted_token< + Arg0: ProxyArg>, + Arg1: ProxyArg, + >( + self, + chain_specific_token_id: Arg0, + chain_specific_token_decimals: Arg1, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("updateWhitelistedToken") + .argument(&chain_specific_token_id) + .argument(&chain_specific_token_decimals) + .original_result() + } + + pub fn blacklist_token< + Arg0: ProxyArg>, + >( + self, + chain_specific_token_id: Arg0, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("blacklistToken") + .argument(&chain_specific_token_id) + .original_result() + } + + pub fn deposit_liquidity( + self, + ) -> TxTypedCall { + self.wrapped_tx + .raw_call("depositLiquidity") + .original_result() + } + + /// Will wrap what it can, and send back the rest unchanged + pub fn wrap_tokens( + self, + ) -> TxTypedCall>> { + self.wrapped_tx + .raw_call("wrapTokens") + .original_result() + } + + pub fn unwrap_token< + Arg0: ProxyArg>, + >( + self, + requested_token: Arg0, + ) -> TxTypedCall { + self.wrapped_tx + .raw_call("unwrapToken") + .argument(&requested_token) + .original_result() + } + + pub fn unwrap_token_create_transaction< + Arg0: ProxyArg>, + Arg1: ProxyArg>, + >( + self, + requested_token: Arg0, + to: Arg1, + ) -> TxTypedCall { + self.wrapped_tx + .raw_call("unwrapTokenCreateTransaction") + .argument(&requested_token) + .argument(&to) + .original_result() + } + + pub fn universal_bridged_token_ids( + self, + ) -> TxTypedCall>> { + self.wrapped_tx + .payment(NotPayable) + .raw_call("getUniversalBridgedTokenIds") + .original_result() + } + + pub fn token_liquidity< + Arg0: ProxyArg>, + >( + self, + token: Arg0, + ) -> TxTypedCall> { + self.wrapped_tx + .payment(NotPayable) + .raw_call("getTokenLiquidity") + .argument(&token) + .original_result() + } + + pub fn chain_specific_to_universal_mapping< + Arg0: ProxyArg>, + >( + self, + token: Arg0, + ) -> TxTypedCall> { + self.wrapped_tx + .payment(NotPayable) + .raw_call("getChainSpecificToUniversalMapping") + .argument(&token) + .original_result() + } + + pub fn chain_specific_token_ids< + Arg0: ProxyArg>, + >( + self, + universal_token_id: Arg0, + ) -> TxTypedCall>> { + self.wrapped_tx + .payment(NotPayable) + .raw_call("getchainSpecificTokenIds") + .argument(&universal_token_id) + .original_result() + } + + pub fn pause_endpoint( + self, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("pause") + .original_result() + } + + pub fn unpause_endpoint( + self, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("unpause") + .original_result() + } + + pub fn paused_status( + self, + ) -> TxTypedCall { + self.wrapped_tx + .payment(NotPayable) + .raw_call("isPaused") + .original_result() + } +} diff --git a/bridge-proxy/src/config.rs b/bridge-proxy/src/config.rs index f27ca837..b02ad462 100644 --- a/bridge-proxy/src/config.rs +++ b/bridge-proxy/src/config.rs @@ -23,17 +23,17 @@ pub trait ConfigModule { } #[only_owner] - #[endpoint(setupEsdtSafe)] - fn set_esdt_safe_contract_address(&self, opt_esdt_safe_address: OptionalValue) { - match opt_esdt_safe_address { + #[endpoint(setBridgedTokensWrapper)] + fn set_bridged_tokens_wrapper(&self, opt_address: OptionalValue) { + match opt_address { OptionalValue::Some(sc_addr) => { require!( self.blockchain().is_smart_contract(&sc_addr), - "Invalid multi-transfer address" + "Invalid bridged tokens wrapper address" ); - self.esdt_safe_address().set(&sc_addr); + self.bridged_tokens_wrapper_address().set(&sc_addr); } - OptionalValue::None => self.esdt_safe_address().clear(), + OptionalValue::None => self.bridged_tokens_wrapper_address().clear(), } } @@ -41,16 +41,16 @@ pub trait ConfigModule { #[storage_mapper("multiTransferAddress")] fn multi_transfer_address(&self) -> SingleValueMapper; - #[view(getEsdtSafeAddress)] - #[storage_mapper("esdtSafeAddress")] - fn esdt_safe_address(&self) -> SingleValueMapper; - - #[proxy] - fn esdt_safe_proxy(&self, sc_address: ManagedAddress) -> esdt_safe::Proxy; + #[view(getBridgedTokensWrapperAddress)] + #[storage_mapper("bridgedTokensWrapperAddress")] + fn bridged_tokens_wrapper_address(&self) -> SingleValueMapper; #[storage_mapper("pending_transactions")] fn pending_transactions(&self) -> VecMapper>; + #[storage_mapper("payments")] + fn payments(&self, tx_id: usize) -> SingleValueMapper>; + #[storage_mapper("lowest_tx_id")] fn lowest_tx_id(&self) -> SingleValueMapper; } diff --git a/bridge-proxy/wasm/src/lib.rs b/bridge-proxy/wasm/src/lib.rs index fef3cc2e..8a2eeddc 100644 --- a/bridge-proxy/wasm/src/lib.rs +++ b/bridge-proxy/wasm/src/lib.rs @@ -26,9 +26,9 @@ multiversx_sc_wasm_adapter::endpoints! { getPendingTransactionById => get_pending_transaction_by_id getPendingTransactions => get_pending_transactions setupMultiTransfer => set_multi_transfer_contract_address - setupEsdtSafe => set_esdt_safe_contract_address + setBridgedTokensWrapper => set_bridged_tokens_wrapper getMultiTransferAddress => multi_transfer_address - getEsdtSafeAddress => esdt_safe_address + getBridgedTokensWrapperAddress => bridged_tokens_wrapper_address pause => pause_endpoint unpause => unpause_endpoint isPaused => paused_status diff --git a/bridged-tokens-wrapper/Cargo.toml b/bridged-tokens-wrapper/Cargo.toml index 71af86c6..2b2a3c8c 100644 --- a/bridged-tokens-wrapper/Cargo.toml +++ b/bridged-tokens-wrapper/Cargo.toml @@ -11,6 +11,15 @@ path = "src/lib.rs" [dependencies.transaction] path = "../common/transaction" +[dependencies.eth-address] +path = "../common/eth-address" + +[dependencies.token-module] +path = "../common/token-module" + +[dependencies.tx-batch-module] +path = "../common/tx-batch-module" + [dependencies.multiversx-sc] version = "=0.51.1" diff --git a/bridge-proxy/src/esdt_safe_proxy.rs b/bridged-tokens-wrapper/src/esdt_safe_proxy.rs similarity index 100% rename from bridge-proxy/src/esdt_safe_proxy.rs rename to bridged-tokens-wrapper/src/esdt_safe_proxy.rs diff --git a/bridged-tokens-wrapper/src/events.rs b/bridged-tokens-wrapper/src/events.rs index c80b91ab..34893fba 100644 --- a/bridged-tokens-wrapper/src/events.rs +++ b/bridged-tokens-wrapper/src/events.rs @@ -4,5 +4,5 @@ pub trait EventsModule { fn wrap_tokens_event(&self, #[indexed] token_id: TokenIdentifier, #[indexed] amount: BigUint); #[event("unwrap_tokens")] - fn unwrap_tokens_event(&self, #[indexed] token_id: TokenIdentifier, #[indexed] amount: BigUint); + fn unwrap_tokens_event(&self, #[indexed] token_id: &TokenIdentifier, #[indexed] amount: BigUint); } diff --git a/bridged-tokens-wrapper/src/lib.rs b/bridged-tokens-wrapper/src/lib.rs index 4776bcf1..ca28c6b2 100644 --- a/bridged-tokens-wrapper/src/lib.rs +++ b/bridged-tokens-wrapper/src/lib.rs @@ -1,12 +1,14 @@ #![no_std] mod dfp_big_uint; +mod esdt_safe_proxy; mod events; use core::ops::Deref; pub use dfp_big_uint::DFPBigUint; use transaction::PaymentsVec; +use eth_address::*; use multiversx_sc::imports::*; impl DFPBigUint {} @@ -194,18 +196,26 @@ pub trait BridgedTokensWrapper: #[payable("*")] #[endpoint(unwrapToken)] fn unwrap_token(&self, requested_token: TokenIdentifier) { + let converted_amount = self.unwrap_token_common(&requested_token); + self.tx() + .to(ToCaller) + .single_esdt(&requested_token, 0, &converted_amount) + .transfer(); + } + + fn unwrap_token_common(&self, requested_token: &TokenIdentifier) -> BigUint { require!(self.not_paused(), "Contract is paused"); let (payment_token, payment_amount) = self.call_value().single_fungible_esdt(); require!(payment_amount > 0u32, "Must pay more than 0 tokens!"); let universal_bridged_token_ids = self - .chain_specific_to_universal_mapping(&requested_token) + .chain_specific_to_universal_mapping(requested_token) .get(); require!( payment_token == universal_bridged_token_ids, "Esdt token unavailable" ); - self.require_tokens_have_set_decimals_num(&payment_token, &requested_token); + self.require_tokens_have_set_decimals_num(&payment_token, requested_token); let chain_specific_token_id = &requested_token; let converted_amount = self.get_converted_amount( @@ -226,12 +236,24 @@ pub trait BridgedTokensWrapper: self.send() .esdt_local_burn(&universal_bridged_token_ids, 0, &payment_amount); - self.tx() - .to(ToCaller) - .single_esdt(chain_specific_token_id, 0, &converted_amount) - .transfer(); + self.unwrap_tokens_event(chain_specific_token_id, converted_amount.clone()); + converted_amount + } - self.unwrap_tokens_event(chain_specific_token_id.clone(), converted_amount); + #[payable("*")] + #[endpoint(unwrapTokenCreateTransaction)] + fn unwrap_token_create_transaction( + &self, + requested_token: TokenIdentifier, + to: EthAddress, + ) { + let converted_amount = self.unwrap_token_common(&requested_token); + self.tx() + .to(self.esdt_safe_contract_address().get()) + .typed(esdt_safe_proxy::EsdtSafeProxy) + .create_transaction(to) + .single_esdt(&requested_token, 0, &converted_amount) + .sync_call(); } fn get_converted_amount( @@ -270,6 +292,17 @@ pub trait BridgedTokensWrapper: ); } + #[only_owner] + #[endpoint(setEsdtSafeContractAddress)] + fn set_esdt_safe_contract_address(&self, opt_new_address: OptionalValue) { + match opt_new_address { + OptionalValue::Some(sc_addr) => { + self.esdt_safe_contract_address().set(&sc_addr); + } + OptionalValue::None => self.esdt_safe_contract_address().clear(), + } + } + #[view(getUniversalBridgedTokenIds)] #[storage_mapper("universalBridgedTokenIds")] fn universal_bridged_token_ids(&self) -> UnorderedSetMapper; @@ -294,4 +327,8 @@ pub trait BridgedTokensWrapper: #[storage_mapper("token_decimals_num")] fn token_decimals_num(&self, token: &TokenIdentifier) -> SingleValueMapper; + + #[view(getEsdtSafeContractAddress)] + #[storage_mapper("esdtSafeContractAddress")] + fn esdt_safe_contract_address(&self) -> SingleValueMapper; } diff --git a/bridged-tokens-wrapper/wasm/Cargo.lock b/bridged-tokens-wrapper/wasm/Cargo.lock index b2be7478..d0dc546c 100644 --- a/bridged-tokens-wrapper/wasm/Cargo.lock +++ b/bridged-tokens-wrapper/wasm/Cargo.lock @@ -24,9 +24,12 @@ checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" name = "bridged-tokens-wrapper" version = "0.0.0" dependencies = [ + "eth-address", "multiversx-sc", "multiversx-sc-modules", + "token-module", "transaction", + "tx-batch-module", ] [[package]] @@ -50,6 +53,13 @@ dependencies = [ "multiversx-sc", ] +[[package]] +name = "fee-estimator-module" +version = "0.0.0" +dependencies = [ + "multiversx-sc", +] + [[package]] name = "hex" version = "0.4.3" @@ -193,6 +203,14 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "token-module" +version = "0.0.0" +dependencies = [ + "fee-estimator-module", + "multiversx-sc", +] + [[package]] name = "transaction" version = "0.0.0" @@ -201,6 +219,14 @@ dependencies = [ "multiversx-sc", ] +[[package]] +name = "tx-batch-module" +version = "0.0.0" +dependencies = [ + "multiversx-sc", + "transaction", +] + [[package]] name = "unicode-ident" version = "1.0.12" diff --git a/bridged-tokens-wrapper/wasm/src/lib.rs b/bridged-tokens-wrapper/wasm/src/lib.rs index ce3674c9..29f9d9c1 100644 --- a/bridged-tokens-wrapper/wasm/src/lib.rs +++ b/bridged-tokens-wrapper/wasm/src/lib.rs @@ -6,9 +6,9 @@ // Init: 1 // Upgrade: 1 -// Endpoints: 16 +// Endpoints: 19 // Async Callback (empty): 1 -// Total number of exported functions: 19 +// Total number of exported functions: 22 #![no_std] @@ -29,10 +29,13 @@ multiversx_sc_wasm_adapter::endpoints! { depositLiquidity => deposit_liquidity wrapTokens => wrap_tokens unwrapToken => unwrap_token + unwrapTokenCreateTransaction => unwrap_token_create_transaction + setEsdtSafeContractAddress => set_esdt_safe_contract_address getUniversalBridgedTokenIds => universal_bridged_token_ids getTokenLiquidity => token_liquidity getChainSpecificToUniversalMapping => chain_specific_to_universal_mapping getchainSpecificTokenIds => chain_specific_token_ids + getEsdtSafeContractAddress => esdt_safe_contract_address pause => pause_endpoint unpause => unpause_endpoint isPaused => paused_status diff --git a/multi-transfer-esdt/src/bridged_tokens_wrapper_proxy.rs b/multi-transfer-esdt/src/bridged_tokens_wrapper_proxy.rs index 4a0d3601..fbfdbaaa 100644 --- a/multi-transfer-esdt/src/bridged_tokens_wrapper_proxy.rs +++ b/multi-transfer-esdt/src/bridged_tokens_wrapper_proxy.rs @@ -203,6 +203,21 @@ where .original_result() } + pub fn unwrap_token_create_transaction< + Arg0: ProxyArg>, + Arg1: ProxyArg>, + >( + self, + requested_token: Arg0, + to: Arg1, + ) -> TxTypedCall { + self.wrapped_tx + .raw_call("unwrapTokenCreateTransaction") + .argument(&requested_token) + .argument(&to) + .original_result() + } + pub fn universal_bridged_token_ids( self, ) -> TxTypedCall>> { diff --git a/multi-transfer-esdt/src/lib.rs b/multi-transfer-esdt/src/lib.rs index 900bf29e..590d8e49 100644 --- a/multi-transfer-esdt/src/lib.rs +++ b/multi-transfer-esdt/src/lib.rs @@ -248,9 +248,7 @@ pub trait MultiTransferEsdt: payments: PaymentsVec, ) { let bridge_proxy_addr = self.bridge_proxy_contract_address().get(); - for (mut eth_tx, p) in transfers.iter().zip(payments.iter()) { - eth_tx.amount = p.amount.clone(); - eth_tx.token_id = p.token_identifier.clone(); + for (eth_tx, p) in transfers.iter().zip(payments.iter()) { if self.blockchain().is_smart_contract(ð_tx.to) { self.tx() .to(bridge_proxy_addr.clone()) diff --git a/multi-transfer-esdt/tests/multi_transfer_blackbox_test.rs b/multi-transfer-esdt/tests/multi_transfer_blackbox_test.rs index 4c7fdc3a..4ecd974a 100644 --- a/multi-transfer-esdt/tests/multi_transfer_blackbox_test.rs +++ b/multi-transfer-esdt/tests/multi_transfer_blackbox_test.rs @@ -1,11 +1,11 @@ #![allow(unused)] -use bridge_proxy::{ - bridge_proxy_contract_proxy, config::ProxyTrait as _, esdt_safe_proxy, ProxyTrait as _, -}; +use bridge_proxy::{bridge_proxy_contract_proxy, config::ProxyTrait as _, ProxyTrait as _}; use bridged_tokens_wrapper::ProxyTrait as _; use esdt_safe::{EsdtSafe, ProxyTrait as _}; -use multi_transfer_esdt::{bridged_tokens_wrapper_proxy, multi_transfer_proxy, ProxyTrait as _}; +use multi_transfer_esdt::{ + bridged_tokens_wrapper_proxy, esdt_safe_proxy, multi_transfer_proxy, ProxyTrait as _, +}; use multiversx_sc::{ api::{HandleConstraints, ManagedTypeApi}, @@ -93,60 +93,6 @@ struct MultiTransferTestState { impl MultiTransferTestState { fn new() -> Self { - // let world = world(); - // let ic = &world.interpreter_context(); - - // let mut state: MultiTransferTestState = MultiTransferTestState { - // world, - // owner: "address:owner".into(), - // user1: "address:user1".into(), - // user2: "address:user2".into(), - // eth_user: EthAddress { - // raw_addr: ManagedByteArray::default(), - // }, - // multi_transfer: MultiTransferContract::new("sc:multi_transfer"), - // bridge_proxy: BridgeProxyContract::new("sc:bridge_proxy"), - // esdt_safe: EsdtSafeContract::new("sc:esdt_safe"), - // bridged_tokens_wrapper: BridgedTokensWrapperContract::new("sc:bridged_tokens_wrapper"), - // }; - - // let multi_transfer_code = state.world.code_expression(MULTI_TRANSFER_PATH_EXPR); - // let bridge_proxy_code = state.world.code_expression(BRIDGE_PROXY_PATH_EXPR); - // let esdt_safe_code = state.world.code_expression(ESDT_SAFE_PATH_EXPR); - // let bridged_tokens_wrapper_code = state - // .world - // .code_expression(BRIDGED_TOKENS_WRAPPER_PATH_EXPR); - - // let roles = vec![ - // "ESDTRoleLocalMint".to_string(), - // "ESDTRoleLocalBurn".to_string(), - // ]; - - // state.world.set_state_step( - // SetStateStep::new() - // .put_account( - // &state.owner, - // Account::new() - // .nonce(1) - // .balance(BALANCE) - // .esdt_balance(BRIDGE_TOKEN_ID_EXPR, BALANCE), - // ) - // .put_account(&state.user1, Account::new().nonce(1)) - // .new_address(&state.owner, 1, MULTI_TRANSFER_ADDRESS_EXPR) - // .new_address(&state.owner, 2, BRIDGE_PROXY_ADDRESS_EXPR) - // .new_address(&state.owner, 3, ESDT_SAFE_ADDRESS_EXPR) - // .put_account( - // ESDT_SAFE_ADDRESS_EXPR, - // Account::new() - // .code(&esdt_safe_code) - // .owner(&state.owner) - // .esdt_roles(BRIDGE_TOKEN_ID_EXPR, roles) - // .esdt_balance(BRIDGE_TOKEN_ID_EXPR, "1_000"), - // ) - // .new_address(&state.owner, 4, BRIDGED_TOKENS_WRAPPER_ADDRESS_EXPR), - // ); - // state - let mut world = world(); world diff --git a/multi-transfer-esdt/wasm/Cargo.lock b/multi-transfer-esdt/wasm/Cargo.lock index b5f727a4..022fdfb5 100644 --- a/multi-transfer-esdt/wasm/Cargo.lock +++ b/multi-transfer-esdt/wasm/Cargo.lock @@ -46,9 +46,12 @@ dependencies = [ name = "bridged-tokens-wrapper" version = "0.0.0" dependencies = [ + "eth-address", "multiversx-sc", "multiversx-sc-modules", + "token-module", "transaction", + "tx-batch-module", ] [[package]] diff --git a/multisig/wasm/Cargo.lock b/multisig/wasm/Cargo.lock index 37122e69..2dd43961 100644 --- a/multisig/wasm/Cargo.lock +++ b/multisig/wasm/Cargo.lock @@ -46,9 +46,12 @@ dependencies = [ name = "bridged-tokens-wrapper" version = "0.0.0" dependencies = [ + "eth-address", "multiversx-sc", "multiversx-sc-modules", + "token-module", "transaction", + "tx-batch-module", ] [[package]]