Feat v3.5

contracts/Bridge.sol

@@ -6,6 +6,7 @@ import "./SharedStructs.sol";
 import "./ERC20Safe.sol";
 import "./access/RelayerRole.sol";
 import "./lib/Pausable.sol";
+import "./BridgeProxy.sol";
 
 /**
 @title Bridge
@@ -35,6 +36,7 @@ contract Bridge is RelayerRole, Pausable {
 
     uint256 public quorum;
     ERC20Safe internal immutable safe;
+    BridgeProxy internal bridgeProxy;
 
     mapping(uint256 => bool) public executedBatches;
     mapping(uint256 => CrossTransferStatus) public crossTransferStatuses;
@@ -48,14 +50,15 @@ contract Bridge is RelayerRole, Pausable {
      *   - add/remove relayers
      *   - add/remove tokens that can be bridged
      */
-    constructor(address[] memory board, uint256 initialQuorum, ERC20Safe erc20Safe) {
+    constructor(address[] memory board, uint256 initialQuorum, ERC20Safe erc20Safe, BridgeProxy _bridgeProxy) {
         require(initialQuorum >= minimumQuorum, "Quorum is too low.");
         require(board.length >= initialQuorum, "The board should be at least the quorum size.");
 
         _addRelayers(board);
 
         quorum = initialQuorum;
         safe = erc20Safe;
+        bridgeProxy = _bridgeProxy;
     }
 
     /**
@@ -97,20 +100,21 @@ contract Bridge is RelayerRole, Pausable {
     }
 
     /**
-        @notice Executes transfers that were signed by the relayers.
-        @dev This is for the MultiversX to Ethereum flow
-        @dev Arrays here try to mimmick the structure of a batch. A batch represents the values from the same index in all the arrays.
-        @param tokens Array containing all the token addresses that the batch interacts with. Can even contain duplicates.
-        @param recipients Array containing all the destinations from the batch. Can be duplicates.
-        @param amounts Array containing all the amounts that will be transfered.
-        @param batchNonceMvx Nonce for the batch. This identifies a batch created on the MultiversX chain that bridges tokens from MultiversX to Ethereum
-        @param signatures Signatures from all the relayers for the execution. This mimics a delegated multisig contract. For the execution to take place, there must be enough valid signatures to achieve quorum.
+        @notice Executes a batch of transfers
+        @param mvxTransactions List of transactions from MultiversX side. Each transaction consists of:
+        - token address
+        - sender
+        - recipient
+        - amount
+        - deposit nonce
+        - call data
+        - true, if recipient a smart contract
+          false, otherwise
+        @param batchNonceMvx Nonce for the batch
+        @param signatures List of signatures from the relayers
     */
     function executeTransfer(
-        address[] calldata tokens,
-        address[] calldata recipients,
-        uint256[] calldata amounts,
-        uint256[] calldata depositNonces,
+        MvxTransaction[] calldata mvxTransactions,
         uint256 batchNonceMvx,
         bytes[] calldata signatures
     ) public whenNotPaused onlyRelayer {
@@ -120,16 +124,12 @@ contract Bridge is RelayerRole, Pausable {
 
         _validateQuorum(
             signatures,
-            _getHashedDepositData(
-                abi.encode(recipients, tokens, amounts, depositNonces, batchNonceMvx, executeTransferAction)
-            )
+            _getHashedDepositData(abi.encode(mvxTransactions, batchNonceMvx, executeTransferAction))
         );
 
-        DepositStatus[] memory statuses = new DepositStatus[](tokens.length);
-        for (uint256 j = 0; j < tokens.length; j++) {
-            statuses[j] = safe.transfer(tokens[j], amounts[j], recipients[j])
-                ? DepositStatus.Executed
-                : DepositStatus.Rejected;
+        DepositStatus[] memory statuses = new DepositStatus[](mvxTransactions.length);
+        for (uint256 j = 0; j < mvxTransactions.length; j++) {
+            statuses[j] = _processDeposit(mvxTransactions[j]);
         }
 
         CrossTransferStatus storage crossStatus = crossTransferStatuses[batchNonceMvx];
@@ -142,7 +142,9 @@ contract Bridge is RelayerRole, Pausable {
         @param batchNonceMvx Nonce for the batch
         @return a list of statuses for each transfer in the batch provided
      */
-    function getStatusesAfterExecution(uint256 batchNonceMvx) external view returns (DepositStatus[] memory, bool isFinal) {
+    function getStatusesAfterExecution(
+        uint256 batchNonceMvx
+    ) external view returns (DepositStatus[] memory, bool isFinal) {
         CrossTransferStatus memory crossStatus = crossTransferStatuses[batchNonceMvx];
         return (crossStatus.statuses, _isMvxBatchFinal(crossStatus.createdBlockNumber));
     }
@@ -164,6 +166,26 @@ contract Bridge is RelayerRole, Pausable {
         return keccak256(abi.encodePacked(prefix, keccak256(encodedData)));
     }
 
+    function _processDeposit(MvxTransaction calldata mvxTransaction) private returns (DepositStatus) {
+        address recipient;
+        if (mvxTransaction.isScRecipient) {
+            recipient = address(bridgeProxy);
+        } else {
+            recipient = mvxTransaction.recipient;
+        }
+
+        DepositStatus status = safe.transfer(mvxTransaction.token, mvxTransaction.amount, recipient)
+            ? DepositStatus.Executed
+            : DepositStatus.Rejected;
+
+        // If the recipient is a smart contract, deposit the funds in the bridgeProxy
+        if (mvxTransaction.isScRecipient && status == DepositStatus.Executed) {
+            bridgeProxy.deposit(mvxTransaction);
+        }
+
+        return status;
+    }
+
     function _validateQuorum(bytes[] memory signatures, bytes32 data) private view {
         uint256 signersCount;
         address[] memory validSigners = new address[](signatures.length);

contracts/BridgeProxy.sol

@@ -0,0 +1,113 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./lib/Pausable.sol";
+import "./SharedStructs.sol";
+import "./lib/BoolTokenTransfer.sol";
+import "./access/AdminRole.sol";
+import "./access/BridgeRole.sol";
+
+contract BridgeProxy is Pausable, BridgeRole {
+    using BoolTokenTransfer for IERC20;
+
+    uint256 public constant MIN_GAS_LIMIT_FOR_SC_CALL = 10_000_000;
+    uint256 public constant DEFAULT_GAS_LIMIT_FOR_REFUND_CALLBACK = 20_000_000;
+
+    mapping(uint256 => MvxTransaction) private pendingTransactions;
+    uint256 private lowestTxId;
+    uint256 private currentTxId;
+
+    constructor() Pausable() {
+        lowestTxId = 0;
+    }
+
+    function deposit(MvxTransaction calldata txn) external payable whenNotPaused onlyBridge {
+        pendingTransactions[currentTxId] = txn;
+        currentTxId++;
+    }
+
+    function execute(uint256 txId) external whenNotPaused {
+        require(txId < currentTxId, "BridgeProxy: Invalid transaction ID");
+        MvxTransaction memory txn = pendingTransactions[txId];
+
+        require(txn.amount != 0, "BridgeProxy: No amount bridged");
+
+        if (txn.callData.length > 0) {
+            (bytes memory selector, uint256 gasLimit, bytes memory args) = abi.decode(
+                txn.callData,
+                (bytes, uint256, bytes)
+            );
+
+            if (selector.length == 0 || gasLimit == 0 || gasLimit < MIN_GAS_LIMIT_FOR_SC_CALL) {
+                _finishExecuteGracefully(txId, true);
+                return;
+            }
+
+            bytes memory data;
+            if (args.length > 0) {
+                data = abi.encodePacked(selector, args);
+            } else {
+                data = selector;
+            }
+
+            (bool success, ) = txn.recipient.call{ gas: gasLimit }(data);
+
+            bool isRefund = !success;
+            _finishExecuteGracefully(txId, isRefund);
+        } else {
+            _finishExecuteGracefully(txId, true);
+        }
+    }
+
+    function _finishExecuteGracefully(uint256 txId, bool isRefund) private {
+        if (isRefund) {
+            _refundTransaction(txId);
+        }
+        _updateLowestTxId();
+        delete pendingTransactions[txId];
+    }
+
+    function _refundTransaction(uint256 txId) private {
+        MvxTransaction memory txn = pendingTransactions[txId];
+
+        IERC20 erc20 = IERC20(txn.token);
+        bool transferExecuted = erc20.boolTransfer(this.bridge(), txn.amount);
+        require(transferExecuted, "BridgeProxy: Refund failed");
+    }
+
+    function _updateLowestTxId() private {
+        uint256 newLowestTxId = lowestTxId;
+
+        while (newLowestTxId < currentTxId && pendingTransactions[newLowestTxId].amount == 0) {
+            newLowestTxId++;
+        }
+
+        lowestTxId = newLowestTxId;
+    }
+
+    function getPendingTransactionById(uint256 txId) public view returns (MvxTransaction memory) {
+        return pendingTransactions[txId];
+    }
+
+    function getPendingTransaction() public view returns (MvxTransaction[] memory) {
+        uint256 pendingTransactionsCount = currentTxId - lowestTxId;
+        MvxTransaction[] memory txns = new MvxTransaction[](pendingTransactionsCount);
+        uint256 index = 0;
+
+        for (uint256 i = lowestTxId; i < currentTxId; i++) {
+            if (pendingTransactions[i].amount != 0) {
+                txns[index] = pendingTransactions[i];
+                index++;
+            }
+        }
+
+        // Resize the array to the actual number of pending transactions
+        assembly {
+            mstore(txns, index)
+        }
+
+        return txns;
+    }
+}

contracts/SharedStructs.sol

@@ -34,3 +34,13 @@ struct Batch {
 struct DepositSCExtension {
     string depositData;
 }
+
+struct MvxTransaction {
+    address token;
+    bytes32 sender;
+    address recipient;
+    uint256 amount;
+    uint256 depositNonce;
+    bytes callData;
+    bool isScRecipient;
+}

contracts/test/BridgeMock.sol

@@ -8,8 +8,9 @@ contract BridgeMock is Bridge {
     constructor(
         address[] memory board,
         uint256 initialQuorum,
-        ERC20Safe erc20Safe
-    ) Bridge(board, initialQuorum, erc20Safe) {}
+        ERC20Safe erc20Safe,
+        BridgeProxy bridgeProxy
+    ) Bridge(board, initialQuorum, erc20Safe, bridgeProxy) {}
 
     function proxyTransfer(address tokenAddress, uint256 amount, address recipientAddress) external returns (bool) {
         return safe.transfer(tokenAddress, amount, recipientAddress);

contracts/test/Counter.sol

@@ -0,0 +1,15 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.20;
+
+contract Counter {
+    uint256 public count;
+
+    constructor() {
+        count = 0;
+    }
+
+    function increment() public {
+        count += 1;
+    }
+}