Merge pull request #170 from multiversx/bridge-proxy-improvements

Bridge proxy improvements

bridge-proxy/Cargo.toml

@@ -14,6 +14,9 @@ path = "../common/transaction"
 [dependencies.eth-address]
 path = "../common/eth-address"
 
+[dependencies.esdt-safe]
+path = "../esdt-safe"
+
 [dependencies.multiversx-sc]
 version = "=0.47.5"
 

bridge-proxy/src/bridge-proxy.rs

@@ -5,7 +5,8 @@ multiversx_sc::derive_imports!();
 
 pub mod config;
 
-use transaction::{EthTransaction, EthTransactionPayment};
+use esdt_safe::ProxyTrait as _;
+use transaction::EthTransaction;
 
 #[multiversx_sc::contract]
 pub trait BridgeProxyContract:
@@ -26,76 +27,58 @@ pub trait BridgeProxyContract:
     #[endpoint]
     fn deposit(&self, eth_tx: EthTransaction<Self::Api>) {
         self.require_not_paused();
-        let (token_id, nonce, amount) = self.call_value().single_esdt().into_tuple();
-        self.eth_transaction_list()
-            .push_back(EthTransactionPayment {
-                token_id,
-                nonce,
-                amount,
-                eth_tx,
-            });
+        let (token_id, amount) = self.call_value().single_fungible_esdt();
+        require!(token_id == eth_tx.token_id, "Invalid token id");
+        require!(amount == eth_tx.amount, "Invalid amount");
+        self.pending_transactions().push(&eth_tx);
     }
 
     #[endpoint(executeWithAsnyc)]
-    fn execute_with_async(&self, tx_id: u32) {
+    fn execute_with_async(&self, tx_id: usize) {
         self.require_not_paused();
-        let tx_node = self
-            .eth_transaction_list()
-            .remove_node_by_id(tx_id)
-            .unwrap_or_else(|| sc_panic!("Invalid ETH transaction!"));
-        let tx = tx_node.get_value_as_ref();
+        let tx = self.get_pending_transaction_by_id(tx_id);
 
         require!(
-            tx.eth_tx.call_data.is_some(),
+            tx.call_data.is_some(),
             "There is no data for a SC call!"
         );
 
-        let call_data = unsafe { tx.eth_tx.call_data.clone().unwrap_unchecked() };
+        let call_data = unsafe { tx.call_data.clone().unwrap_unchecked() };
         self.send()
-            .contract_call::<IgnoreValue>(tx.eth_tx.to.clone(), call_data.endpoint.clone())
+            .contract_call::<IgnoreValue>(tx.to.clone(), call_data.endpoint.clone())
             .with_raw_arguments(call_data.args.clone().into())
-            .with_esdt_transfer((tx.token_id.clone(), tx.nonce, tx.amount.clone()))
+            .with_esdt_transfer((tx.token_id.clone(), 0, tx.amount.clone()))
             .with_gas_limit(call_data.gas_limit)
-            .async_call()
-            .with_callback(self.callbacks().failed_execution_callback(tx))
-            .call_and_exit();
+            .async_call_promise()
+            .with_callback(self.callbacks().execution_callback(tx_id))
+            .register_promise();
     }
 
-    #[callback]
-    fn failed_execution_callback(
+    #[promises_callback]
+    fn execution_callback(
         &self,
         #[call_result] result: ManagedAsyncCallResult<()>,
-        tx: &EthTransactionPayment<Self::Api>,
+        tx_id: usize,
     ) {
         if result.is_err() {
-            self.eth_failed_transaction_list().push_back(tx.clone());
+            self.refund_transaction(tx_id);
         }
+        self.pending_transactions().clear_entry_unchecked(tx_id);
     }
 
-    #[endpoint(refundTransactions)]
-    fn refund_transactions(&self) -> MultiValueEncoded<EthTransactionPayment<Self::Api>> {
-        self.require_not_paused();
-        // Send Failed Tx Structure
-        let mut result = MultiValueEncoded::new();
-        for tx_loop in self.eth_failed_transaction_list().iter() {
-            let tx = tx_loop.get_value_cloned();
-            result.push(tx);
-        }
+    fn refund_transaction(&self, tx_id: usize) {
+        let tx = self.get_pending_transaction_by_id(tx_id);
 
-        // Send Funds
-        let mut all_payments = ManagedVec::new();
-        for failed_tx_loop in self.eth_failed_transaction_list().into_iter() {
-            let failed_tx = failed_tx_loop.get_value_as_ref();
-
-            all_payments.push(EsdtTokenPayment::new(
-                failed_tx.token_id.clone(),
-                failed_tx.nonce,
-                failed_tx.amount.clone(),
-            ));
-        }
-        self.send()
-            .direct_multi(&self.multi_transfer_address().get(), &all_payments);
+        let _: IgnoreValue = self
+            .get_esdt_safe_proxy_instance()
+            .create_transaction(tx.from)
+            .with_esdt_transfer((tx.token_id.clone(), 0, tx.amount.clone()))
+            .execute_on_dest_context();
+    }
 
-        result
+    #[view(getPendingTransactionById)]
+    fn get_pending_transaction_by_id(&self, tx_id: usize) -> EthTransaction<Self::Api> {
+        self.pending_transactions().get_or_else(tx_id, || panic!("Invalid tx id"))
     }
+
 }

bridge-proxy/src/config.rs

@@ -1,7 +1,7 @@
 multiversx_sc::imports!();
 multiversx_sc::derive_imports!();
 
-use transaction::{EthTransaction, EthTransactionPayment};
+use transaction::EthTransaction;
 
 #[multiversx_sc::module]
 pub trait ConfigModule {
@@ -23,24 +23,40 @@ pub trait ConfigModule {
         }
     }
 
-    #[view(getEthTransactionById)]
-    fn get_eth_transaction_by_id(&self, id: u32) -> EthTransaction<Self::Api> {
-        let eth_tx_list = self.eth_transaction_list();
-        match eth_tx_list.get_node_by_id(id) {
-            Some(tx) => tx.get_value_cloned().eth_tx,
-            None => sc_panic!("No transaction with this id!"),
+    #[only_owner]
+    #[endpoint(setupEsdtSafe)]
+    fn set_esdt_safe_contract_address(
+        &self,
+        opt_esdt_safe_address: OptionalValue<ManagedAddress>,
+    ) {
+        match opt_esdt_safe_address {
+            OptionalValue::Some(sc_addr) => {
+                require!(
+                    self.blockchain().is_smart_contract(&sc_addr),
+                    "Invalid multi-transfer address"
+                );
+                self.esdt_safe_address().set(&sc_addr);
+            }
+            OptionalValue::None => self.esdt_safe_address().clear(),
         }
     }
 
+    fn get_esdt_safe_proxy_instance(&self) -> esdt_safe::Proxy<Self::Api> {
+        self.esdt_safe_proxy(self.esdt_safe_address().get())
+    }
+
     #[view(getMultiTransferAddress)]
     #[storage_mapper("multiTransferAddress")]
     fn multi_transfer_address(&self) -> SingleValueMapper<ManagedAddress>;
 
-    #[view(getEthTransactionList)]
-    #[storage_mapper("eth_transaction_list")]
-    fn eth_transaction_list(&self) -> LinkedListMapper<EthTransactionPayment<Self::Api>>;
+    #[view(getEsdtSafeAddress)]
+    #[storage_mapper("esdtSafeAddress")]
+    fn esdt_safe_address(&self) -> SingleValueMapper<ManagedAddress>;
+
+    #[proxy]
+    fn esdt_safe_proxy(&self, sc_address: ManagedAddress) -> esdt_safe::Proxy<Self::Api>;
 
-    #[view(getEthFailedTransactionList)]
-    #[storage_mapper("eth_failed_transaction_list")]
-    fn eth_failed_transaction_list(&self) -> LinkedListMapper<EthTransactionPayment<Self::Api>>;
+    #[view(getPendingTransactions)]
+    #[storage_mapper("pending_transactions")]
+    fn pending_transactions(&self) -> VecMapper<EthTransaction<Self::Api>>;
 }

bridge-proxy/tests/bridge_proxy_blackbox_test.rs

@@ -27,7 +27,7 @@ use multiversx_sc_scenario::{
 };
 
 use eth_address::*;
-use transaction::{CallData, EthTransaction, EthTransactionPayment};
+use transaction::{CallData, EthTransaction};
 
 const BRIDGE_TOKEN_ID: &[u8] = b"BRIDGE-123456";
 const GAS_LIMIT: u64 = 1_000_000;
@@ -161,7 +161,7 @@ fn deploy_deposit_test() {
     test.world.sc_query(
         ScQueryStep::new()
             .to(&test.bridge_proxy_contract)
-            .call(test.bridge_proxy_contract.get_eth_transaction_by_id(1u32))
+            .call(test.bridge_proxy_contract.get_pending_transaction_by_id(1u32))
             .expect_value(eth_tx),
     );
 
@@ -251,14 +251,14 @@ fn multiple_deposit_test() {
     test.world.sc_query(
         ScQueryStep::new()
             .to(&test.bridge_proxy_contract)
-            .call(test.bridge_proxy_contract.get_eth_transaction_by_id(1u32))
+            .call(test.bridge_proxy_contract.get_pending_transaction_by_id(1u32))
             .expect_value(eth_tx1),
     );
 
     test.world.sc_query(
         ScQueryStep::new()
             .to(&test.bridge_proxy_contract)
-            .call(test.bridge_proxy_contract.get_eth_transaction_by_id(2u32))
+            .call(test.bridge_proxy_contract.get_pending_transaction_by_id(2u32))
             .expect_value(eth_tx2),
     );