add mintBurn or locking functionality

common/token-module/src/lib.rs

@@ -67,6 +67,7 @@ pub trait TokenModule: fee_estimator_module::FeeEstimatorModule {
         &self,
         token_id: TokenIdentifier,
         ticker: ManagedBuffer,
+        mint_burn_allowed: bool,
         opt_default_price_per_gas_unit: OptionalValue<BigUint>,
     ) {
         self.token_ticker(&token_id).set(&ticker);
@@ -76,6 +77,7 @@ pub trait TokenModule: fee_estimator_module::FeeEstimatorModule {
                 .set(&default_price_per_gas_unit);
         }
 
+        self.whitelisted_token_mint_burn(&token_id).set(mint_burn_allowed);
         let _ = self.token_whitelist().insert(token_id);
     }
 
@@ -88,8 +90,32 @@ pub trait TokenModule: fee_estimator_module::FeeEstimatorModule {
         let _ = self.token_whitelist().swap_remove(&token_id);
     }
 
+    #[endpoint(getToken)]
+    fn get_token(&self, token_id: &TokenIdentifier, amount: &BigUint) {
+        let caller = self.blockchain().get_caller();
+        require!(caller == self.multi_transfer_contract_address().get(), "Only MultiTransfer can get tokens");
+        if self.whitelisted_token_mint_burn(token_id).get() {
+            self.mint_esdt_token(token_id, amount);
+        }
+
+        self.send().direct_esdt(
+            &self.blockchain().get_caller(),
+            token_id,
+            0,
+            amount,
+        );
+    }
+
     // private
 
+    fn burn_esdt_token(&self, token_id: &TokenIdentifier, amount: &BigUint) {
+        self.send().esdt_local_burn(token_id, 0, amount);
+    }
+
+    fn mint_esdt_token(&self, token_id: &TokenIdentifier, amount: &BigUint) {
+        self.send().esdt_local_mint(token_id, 0, amount);
+    }
+
     fn require_token_in_whitelist(&self, token_id: &TokenIdentifier) {
         require!(
             self.token_whitelist().contains(token_id),
@@ -110,12 +136,35 @@ pub trait TokenModule: fee_estimator_module::FeeEstimatorModule {
         roles.has_role(role)
     }
 
+    #[only_owner]
+    #[endpoint(setMultiTransferContractAddress)]
+    fn set_multi_transfer_contract_address(&self, opt_new_address: OptionalValue<ManagedAddress>) {
+        match opt_new_address {
+            OptionalValue::Some(sc_addr) => {
+                require!(
+                    self.blockchain().is_smart_contract(&sc_addr),
+                    "Invalid multi transfer contract address"
+                );
+
+                self.multi_transfer_contract_address().set(&sc_addr);
+            }
+            OptionalValue::None => self.multi_transfer_contract_address().clear(),
+        }
+    }
+
     // storage
 
     #[view(getAllKnownTokens)]
     #[storage_mapper("tokenWhitelist")]
     fn token_whitelist(&self) -> UnorderedSetMapper<TokenIdentifier>;
 
+    #[storage_mapper("whitelistedTokenMintBurn")]
+    fn whitelisted_token_mint_burn(&self, token: &TokenIdentifier) -> SingleValueMapper<bool>;
+
+    #[view(getMultiTransferContractAddress)]
+    #[storage_mapper("multiTransferContractAddress")]
+    fn multi_transfer_contract_address(&self) -> SingleValueMapper<ManagedAddress>;
+
     #[view(getAccumulatedTransactionFees)]
     #[storage_mapper("accumulatedTransactionFees")]
     fn accumulated_transaction_fees(

esdt-safe/src/lib.rs

@@ -84,7 +84,9 @@ pub trait EsdtSafe:
                     // local burn role might be removed while tx is executed
                     // tokens will remain locked forever in that case
                     // otherwise, the whole batch would fail
-                    if self.is_local_role_set(&tx.token_identifier, &EsdtLocalRole::Burn) {
+                    if self.whitelisted_token_mint_burn(&tx.token_identifier).get()
+                        && self.is_local_role_set(&tx.token_identifier, &EsdtLocalRole::Burn)
+                    {
                         self.burn_esdt_token(&tx.token_identifier, &tx.amount);
                     }
                 }
@@ -243,10 +245,6 @@ pub trait EsdtSafe:
 
     // private
 
-    fn burn_esdt_token(&self, token_id: &TokenIdentifier, amount: &BigUint) {
-        self.send().esdt_local_burn(token_id, 0, amount);
-    }
-
     fn mark_refund(&self, to: &ManagedAddress, token_id: &TokenIdentifier, amount: &BigUint) {
         self.refund_amount(to, token_id)
             .update(|refund| *refund += amount);

esdt-safe/wasm/src/lib.rs

@@ -5,9 +5,9 @@
 ////////////////////////////////////////////////////
 
 // Init:                                 1
-// Endpoints:                           31
+// Endpoints:                           34
 // Async Callback (empty):               1
-// Total number of exported functions:  33
+// Total number of exported functions:  36
 
 #![no_std]
 #![feature(lang_items)]
@@ -35,7 +35,10 @@ multiversx_sc_wasm_adapter::endpoints! {
         distributeFees => distribute_fees
         addTokenToWhitelist => add_token_to_whitelist
         removeTokenFromWhitelist => remove_token_from_whitelist
+        getToken => get_token
+        setMultiTransferContractAddress => set_multi_transfer_contract_address
         getAllKnownTokens => token_whitelist
+        getMultiTransferContractAddress => multi_transfer_contract_address
         getAccumulatedTransactionFees => accumulated_transaction_fees
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration

multi-transfer-esdt/Cargo.toml

@@ -25,6 +25,12 @@ path = "../bridged-tokens-wrapper"
 [dependencies.bridge-proxy]
 path = "../bridge-proxy"
 
+[dependencies.esdt-safe]
+path = "../esdt-safe"
+
+[dependencies.token-module]
+path = "../common/token-module"
+
 [dependencies.multiversx-sc]
 version = "0.42.0"
 [dev-dependencies.multiversx-sc-scenario]

multi-transfer-esdt/src/lib.rs

@@ -5,6 +5,7 @@ multiversx_sc::imports!();
 use transaction::{
     EthTransaction, EthTransactionPayment, PaymentsVec, Transaction, TxBatchSplitInFields,
 };
+use token_module::ProxyTrait as OtherProxyTrait;
 
 const DEFAULT_MAX_TX_BATCH_SIZE: usize = 10;
 const DEFAULT_MAX_TX_BATCH_BLOCK_DURATION: u64 = u64::MAX;
@@ -33,7 +34,7 @@ pub trait MultiTransferEsdt:
         transfers: MultiValueEncoded<EthTransaction<Self::Api>>,
     ) {
         let mut valid_payments_list = ManagedVec::new();
-        let mut valid_dest_addresses_list = ManagedVec::new();
+        let mut valid_tx_list = ManagedVec::new();
         let mut refund_tx_list = ManagedVec::new();
 
         let own_sc_address = self.blockchain().get_sc_address();
@@ -66,26 +67,21 @@ pub trait MultiTransferEsdt:
                 continue;
             }
 
-            self.send()
-                .esdt_local_mint(&eth_tx.token_id, 0, &eth_tx.amount);
+            let _: IgnoreValue = self
+                .get_esdt_safe_contract_proxy_instance()
+                .get_token(&eth_tx.token_id, &eth_tx.amount)
+                .with_esdt_transfer((eth_tx.token_id.clone(), 0, eth_tx.amount.clone()))
+                .execute_on_dest_context();
 
             // emit event before the actual transfer so we don't have to save the tx_nonces as well
             self.transfer_performed_event(batch_id, eth_tx.tx_nonce);
 
-            if self.blockchain().is_smart_contract(&eth_tx.to.clone()) {
-                let _: IgnoreValue = self
-                    .get_bridge_proxy_contract_proxy_instance()
-                    .deposit(&eth_tx)
-                    .with_esdt_transfer((eth_tx.token_id.clone(), 0, eth_tx.amount.clone()))
-                    .execute_on_dest_context();
-            } else {
-                valid_dest_addresses_list.push(eth_tx.to);
-                valid_payments_list.push(EsdtTokenPayment::new(eth_tx.token_id, 0, eth_tx.amount));
-            }
+            valid_tx_list.push(eth_tx.clone());
+            valid_payments_list.push(EsdtTokenPayment::new(eth_tx.token_id, 0, eth_tx.amount));
         }
 
         let payments_after_wrapping = self.wrap_tokens(valid_payments_list);
-        self.distribute_payments(valid_dest_addresses_list, payments_after_wrapping);
+        self.distribute_payments(valid_tx_list, payments_after_wrapping);
 
         self.add_multiple_tx_to_batch(&refund_tx_list);
     }
@@ -136,6 +132,22 @@ pub trait MultiTransferEsdt:
         }
     }
 
+    #[only_owner]
+    #[endpoint(setEsdtSafeContractAddress)]
+    fn set_esdt_safe_contract_address(&self, opt_new_address: OptionalValue<ManagedAddress>) {
+        match opt_new_address {
+            OptionalValue::Some(sc_addr) => {
+                require!(
+                    self.blockchain().is_smart_contract(&sc_addr),
+                    "Invalid esdt safe contract address"
+                );
+
+                self.esdt_safe_contract_address().set(&sc_addr);
+            }
+            OptionalValue::None => self.esdt_safe_contract_address().clear(),
+        }
+    }
+
     #[endpoint(getFailedTxFromBridgeProxy)]
     fn get_failed_tx_from_bridge_proxy(&self) {
         let mut refund_tx_list = ManagedVec::new();
@@ -203,12 +215,21 @@ pub trait MultiTransferEsdt:
 
     fn distribute_payments(
         &self,
-        dest_addresses: ManagedVec<ManagedAddress>,
+        transfers: ManagedVec<EthTransaction<Self::Api>>,
         payments: PaymentsVec<Self::Api>,
     ) {
-        for (dest, p) in dest_addresses.iter().zip(payments.iter()) {
-            self.send()
-                .direct_esdt(&dest, &p.token_identifier, 0, &p.amount);
+        for (eth_tx, p) in transfers.iter().zip(payments.iter()) {
+            if self.blockchain().is_smart_contract(&eth_tx.to.clone()) {
+                let _: IgnoreValue = self
+                    .get_bridge_proxy_contract_proxy_instance()
+                    .deposit(&eth_tx)
+                    .with_esdt_transfer((eth_tx.token_id.clone(), 0, eth_tx.amount.clone()))
+                    .execute_on_dest_context();
+            } else {
+                self.send()
+                    .direct_esdt(&eth_tx.to, &p.token_identifier, 0, &p.amount);
+            }
+
         }
     }
 
@@ -231,6 +252,13 @@ pub trait MultiTransferEsdt:
         self.bridge_proxy(self.bridge_proxy_contract_address().get())
     }
 
+    #[proxy]
+    fn esdt_safe(&self, sc_address: ManagedAddress) -> esdt_safe::Proxy<Self::Api>;
+
+    fn get_esdt_safe_contract_proxy_instance(&self) -> esdt_safe::Proxy<Self::Api> {
+        self.esdt_safe(self.esdt_safe_contract_address().get())
+    }
+
     // storage
     #[view(getWrappingContractAddress)]
     #[storage_mapper("wrappingContractAddress")]
@@ -240,6 +268,10 @@ pub trait MultiTransferEsdt:
     #[storage_mapper("bridgeProxyContractAddress")]
     fn bridge_proxy_contract_address(&self) -> SingleValueMapper<ManagedAddress>;
 
+    #[view(getEsdtSafeContractAddress)]
+    #[storage_mapper("esdtSafeContractAddress")]
+    fn esdt_safe_contract_address(&self) -> SingleValueMapper<ManagedAddress>;
+
     // events
 
     #[event("transferPerformedEvent")]

multi-transfer-esdt/wasm/src/lib.rs

@@ -5,9 +5,9 @@
 ////////////////////////////////////////////////////
 
 // Init:                                 1
-// Endpoints:                           17
+// Endpoints:                           19
 // Async Callback (empty):               1
-// Total number of exported functions:  19
+// Total number of exported functions:  21
 
 #![no_std]
 #![feature(lang_items)]
@@ -23,9 +23,11 @@ multiversx_sc_wasm_adapter::endpoints! {
         getAndClearFirstRefundBatch => get_and_clear_first_refund_batch
         setWrappingContractAddress => set_wrapping_contract_address
         setBridgeProxyContractAddress => set_bridge_proxy_contract_address
+        setEsdtSafeContractAddress => set_esdt_safe_contract_address
         getFailedTxFromBridgeProxy => get_failed_tx_from_bridge_proxy
         getWrappingContractAddress => wrapping_contract_address
         getBridgeProxyContractAddress => bridge_proxy_contract_address
+        getEsdtSafeContractAddress => esdt_safe_contract_address
         setMaxTxBatchSize => set_max_tx_batch_size
         setMaxTxBatchBlockDuration => set_max_tx_batch_block_duration
         getCurrentTxBatch => get_current_tx_batch

multisig/src/setup.rs

@@ -205,11 +205,30 @@ pub trait SetupModule:
         &self,
         token_id: TokenIdentifier,
         ticker: ManagedBuffer,
+        mint_burn_allowed: bool,
         opt_default_price_per_gas_unit: OptionalValue<BigUint>,
     ) {
         let _: IgnoreValue = self
             .get_esdt_safe_proxy_instance()
-            .add_token_to_whitelist(token_id, ticker, opt_default_price_per_gas_unit)
+            .add_token_to_whitelist(token_id, ticker, mint_burn_allowed, opt_default_price_per_gas_unit)
+            .execute_on_dest_context();
+    }
+
+    #[only_owner]
+    #[endpoint(setMultiTransferOnEsdtSafe)]
+    fn set_multi_transfer_on_esdt_safe(&self) {
+        let _: IgnoreValue = self
+            .get_esdt_safe_proxy_instance()
+            .set_multi_transfer_contract_address(self.multi_transfer_esdt_address().get())
+            .execute_on_dest_context();
+    }
+
+    #[only_owner]
+    #[endpoint(setEsdtSafeOnMultiTransfer)]
+    fn set_esdt_safe_on_multi_transfer(&self) {
+        let _: IgnoreValue = self
+            .get_multi_transfer_esdt_proxy_instance()
+            .set_esdt_safe_contract_address(self.esdt_safe_address().get())
             .execute_on_dest_context();
     }