Remove call index from the cross-chain interface

.github/workflows/parachain.yml

@@ -113,14 +113,12 @@ jobs:
         run: rustup show
       - name: run coverage test
         run: >
-          cargo install cargo-tarpaulin &&
+          cargo install cargo-tarpaulin@0.27.0 &&
           cargo tarpaulin
           --manifest-path parachain/Cargo.toml
           --workspace
           --engine llvm
-          --out Xml
-          --exclude substrate-call-index
-          --exclude snowbridge-query-events
+          --out xml
       - name: Upload coverage reports to Codecov with GitHub Action
         uses: codecov/codecov-action@v3
         with:
@@ -133,7 +131,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
         with:
-          submodules: 'true'
+          submodules: "true"
       - uses: arduino/setup-protoc@v2
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}

contracts/src/Assets.sol

@@ -95,17 +95,14 @@ library Assets {
 
     /// @dev Enqueues a create native token message to substrate.
     /// @param token The ERC20 token address.
-    function registerToken(address token, bytes2 createTokenCallID)
-        external
-        returns (bytes memory payload, uint256 extraFee)
-    {
+    function registerToken(address token) external returns (bytes memory payload, uint256 extraFee) {
         AssetsStorage.Layout storage $ = AssetsStorage.layout();
 
         if (!token.isContract()) {
             revert InvalidToken();
         }
 
-        payload = SubstrateTypes.RegisterToken(address(this), token, createTokenCallID);
+        payload = SubstrateTypes.RegisterToken(address(this), token);
         extraFee = $.registerTokenFee;
 
         emit TokenRegistrationSent(token);

contracts/src/DeployScript.sol

@@ -50,19 +50,14 @@ contract DeployScript is Script {
         Gateway gatewayLogic = new Gateway(
             address(beefyClient),
             address(executor),
-            vm.envUint("DISPATCH_GAS"),
             bridgeHubParaID,
             bridgeHubAgentID,
             assetHubParaID,
-            assetHubAgentID,
-            bytes2(vm.envBytes("CREATE_CALL_INDEX"))
+            assetHubAgentID
         );
 
         bytes memory initParams = abi.encode(
-            vm.envUint("DEFAULT_FEE"),
-            vm.envUint("DEFAULT_REWARD"),
-            vm.envUint("REGISTER_NATIVE_TOKEN_FEE"),
-            vm.envUint("SEND_NATIVE_TOKEN_FEE")
+            vm.envUint("DEFAULT_FEE"), vm.envUint("REGISTER_NATIVE_TOKEN_FEE"), vm.envUint("SEND_NATIVE_TOKEN_FEE")
         );
 
         GatewayProxy gateway = new GatewayProxy(address(gatewayLogic), initParams);

contracts/src/FundAgent.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
+pragma solidity 0.8.20;
+
+import {WETH9} from "canonical-weth/WETH9.sol";
+import {Script} from "forge-std/Script.sol";
+import {BeefyClient} from "./BeefyClient.sol";
+
+import {IGateway} from "./interfaces/IGateway.sol";
+import {GatewayProxy} from "./GatewayProxy.sol";
+import {Gateway} from "./Gateway.sol";
+import {GatewayUpgradeMock} from "../test/mocks/GatewayUpgradeMock.sol";
+import {Agent} from "./Agent.sol";
+import {AgentExecutor} from "./AgentExecutor.sol";
+import {ParaID, Config} from "./Types.sol";
+import {SafeNativeTransfer} from "./utils/SafeTransfer.sol";
+import {stdJson} from "forge-std/StdJson.sol";
+
+contract FundAgent is Script {
+    using SafeNativeTransfer for address payable;
+    using stdJson for string;
+
+    function setUp() public {}
+
+    function run() public {
+        uint256 privateKey = vm.envUint("PRIVATE_KEY");
+        address deployer = vm.rememberKey(privateKey);
+        vm.startBroadcast(deployer);
+
+        uint256 initialDeposit = vm.envUint("BRIDGE_HUB_INITIAL_DEPOSIT");
+        address gatewayAddress = vm.envAddress("GATEWAY_PROXY_CONTRACT");
+
+        ParaID bridgeHubParaID = ParaID.wrap(vm.envUint("BRIDGE_HUB_PARAID"));
+        bytes32 bridgeHubAgentID = vm.envBytes32("BRIDGE_HUB_AGENT_ID");
+        ParaID assetHubParaID = ParaID.wrap(vm.envUint("ASSET_HUB_PARAID"));
+        bytes32 assetHubAgentID = vm.envBytes32("ASSET_HUB_AGENT_ID");
+
+        address bridgeHubAgent = IGateway(gatewayAddress).agentOf(bridgeHubAgentID);
+        address assetHubAgent = IGateway(gatewayAddress).agentOf(assetHubAgentID);
+
+        payable(bridgeHubAgent).safeNativeTransfer(initialDeposit);
+        payable(assetHubAgent).safeNativeTransfer(initialDeposit);
+
+        vm.stopBroadcast();
+    }
+}

contracts/src/Gateway.sol

@@ -25,8 +25,7 @@ contract Gateway is IGateway, IInitializable {
     using SafeNativeTransfer for address payable;
 
     // After message dispatch, there should be some gas left over for post dispatch logic
-    uint256 internal constant BUFFER_GAS = 32_000;
-    uint256 internal immutable DISPATCH_GAS;
+    uint256 internal constant BUFFER_GAS = 48_000;
     address internal immutable AGENT_EXECUTOR;
 
     // Verification state
@@ -40,7 +39,12 @@ contract Gateway is IGateway, IInitializable {
     // AssetHub
     ParaID internal immutable ASSET_HUB_PARA_ID;
     bytes32 internal immutable ASSET_HUB_AGENT_ID;
-    bytes2 internal immutable CREATE_TOKEN_CALL_ID;
+
+    // Fixed amount of gas used outside the gas metering in submitInbound
+    uint256 BASE_GAS_USED = 31000;
+
+    // minimum amount of gas required to transfer eth
+    uint256 MINIMUM_THRESHOLD_GAS = 21000;
 
     error InvalidProof();
     error InvalidNonce();
@@ -69,30 +73,25 @@ contract Gateway is IGateway, IInitializable {
     constructor(
         address beefyClient,
         address agentExecutor,
-        uint256 dispatchGas,
         ParaID bridgeHubParaID,
         bytes32 bridgeHubAgentID,
         ParaID assetHubParaID,
-        bytes32 assetHubAgentID,
-        bytes2 createTokenCallID
+        bytes32 assetHubAgentID
     ) {
         if (
-            dispatchGas == 0 || bridgeHubParaID == ParaID.wrap(0) || bridgeHubAgentID == 0
-                || assetHubParaID == ParaID.wrap(0) || assetHubAgentID == 0 || bridgeHubParaID == assetHubParaID
-                || bridgeHubAgentID == assetHubAgentID
+            bridgeHubParaID == ParaID.wrap(0) || bridgeHubAgentID == 0 || assetHubParaID == ParaID.wrap(0)
+                || assetHubAgentID == 0 || bridgeHubParaID == assetHubParaID || bridgeHubAgentID == assetHubAgentID
         ) {
             revert InvalidConstructorParams();
         }
 
         BEEFY_CLIENT = beefyClient;
         AGENT_EXECUTOR = agentExecutor;
-        DISPATCH_GAS = dispatchGas;
         BRIDGE_HUB_PARA_ID_ENCODED = ScaleCodec.encodeU32(uint32(ParaID.unwrap(bridgeHubParaID)));
         BRIDGE_HUB_PARA_ID = bridgeHubParaID;
         BRIDGE_HUB_AGENT_ID = bridgeHubAgentID;
         ASSET_HUB_PARA_ID = assetHubParaID;
         ASSET_HUB_AGENT_ID = assetHubAgentID;
-        CREATE_TOKEN_CALL_ID = createTokenCallID;
     }
 
     /// @dev Submit a message from Polkadot for verification and dispatch
@@ -104,6 +103,8 @@ contract Gateway is IGateway, IInitializable {
         bytes32[] calldata leafProof,
         Verification.Proof calldata headerProof
     ) external {
+        uint256 startGas = gasleft();
+
         Channel storage channel = _ensureChannel(message.origin);
 
         // Ensure this message is not being replayed
@@ -116,13 +117,6 @@ contract Gateway is IGateway, IInitializable {
         // again with the same (message, leafProof, headerProof) arguments.
         channel.inboundNonce++;
 
-        // Reward the relayer from the agent contract
-        // Expected to revert if the agent for the message origin does not have enough funds to reward the relayer.
-        // In that case, the origin should top up the funds of their agent.
-        if (channel.reward > 0) {
-            _transferNativeFromAgent(channel.agent, payable(msg.sender), channel.reward);
-        }
-
         // Produce the commitment (message root) by applying the leaf proof to the message leaf
         bytes32 leafHash = keccak256(abi.encode(message));
         bytes32 commitment = MerkleProof.processProof(leafProof, leafHash);
@@ -136,53 +130,81 @@ contract Gateway is IGateway, IInitializable {
         // Otherwise malicious relayers can break the bridge by allowing the message handlers below to run out gas and fail silently.
         // In this scenario case, the channel's state would have been updated to accept the message (by virtue of the nonce increment), yet the actual message
         // dispatch would have failed
-        if (gasleft() < DISPATCH_GAS + BUFFER_GAS) {
+        uint256 maxDispatchGas = message.maxDispatchGas;
+        if (gasleft() < maxDispatchGas + BUFFER_GAS) {
             revert NotEnoughGas();
         }
 
         bool success = true;
 
         // Dispatch message to a handler
         if (message.command == Command.AgentExecute) {
-            try Gateway(this).agentExecute{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).agentExecute{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.CreateAgent) {
-            try Gateway(this).createAgent{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).createAgent{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.CreateChannel) {
-            try Gateway(this).createChannel{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).createChannel{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.UpdateChannel) {
-            try Gateway(this).updateChannel{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).updateChannel{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.SetOperatingMode) {
-            try Gateway(this).setOperatingMode{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).setOperatingMode{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.TransferNativeFromAgent) {
-            try Gateway(this).transferNativeFromAgent{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).transferNativeFromAgent{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         } else if (message.command == Command.Upgrade) {
-            try Gateway(this).upgrade{gas: DISPATCH_GAS}(message.params) {}
+            try Gateway(this).upgrade{gas: maxDispatchGas}(message.params) {}
             catch {
                 success = false;
             }
         }
 
+        // Calculate the remaining funds in the channel agent contract
+        uint256 agentBalance = channel.agent.balance;
+        if (channel.agent.balance <= MINIMUM_THRESHOLD_GAS * tx.gasprice) {
+            agentBalance = 0;
+        }
+
+        // Calculate the gas refund
+        uint256 gasUsed = startGas - gasleft() + BASE_GAS_USED;
+        uint256 refund = gasUsed * tx.gasprice;
+
+        // Add the reward to the refund amount. If the sum is more than the funds available
+        // in the channel agent, then reduce the total amount
+        uint256 amount = _min(refund + message.reward, agentBalance);
+
+        // Do the payment if there funds available in the agent
+        if (amount > 0) {
+            _transferNativeFromAgent(channel.agent, payable(msg.sender), amount);
+        }
+
         emit IGateway.InboundMessageDispatched(message.origin, message.nonce, success);
     }
 
+    function _min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    function _max(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? b : a;
+    }
+
     /**
      * Getters
      */
@@ -201,9 +223,9 @@ contract Gateway is IGateway, IInitializable {
         return (ch.inboundNonce, ch.outboundNonce);
     }
 
-    function channelFeeRewardOf(ParaID paraID) external view returns (uint256, uint256) {
+    function channelFeeOf(ParaID paraID) external view returns (uint256) {
         Channel storage ch = _ensureChannel(paraID);
-        return (ch.fee, ch.reward);
+        return ch.fee;
     }
 
     function agentOf(bytes32 agentID) external view returns (address) {
@@ -291,7 +313,6 @@ contract Gateway is IGateway, IInitializable {
         ch.inboundNonce = 0;
         ch.outboundNonce = 0;
         ch.fee = $.defaultFee;
-        ch.reward = $.defaultReward;
 
         emit ChannelCreated(params.paraID);
     }
@@ -313,18 +334,13 @@ contract Gateway is IGateway, IInitializable {
 
         Channel storage ch = _ensureChannel(params.paraID);
 
-        // Extra sanity checks when updating the BridgeHub channel. For example, a huge reward could
-        // effectively brick the bridge permanently.
-        if (
-            params.paraID == BRIDGE_HUB_PARA_ID
-                && (params.mode != OperatingMode.Normal || params.fee > 1 ether || params.reward > 1 ether)
-        ) {
+        // Extra sanity checks when updating the BridgeHub channel, which should never be paused.
+        if (params.paraID == BRIDGE_HUB_PARA_ID && (params.mode != OperatingMode.Normal || params.fee > 1 ether)) {
             revert InvalidChannelUpdate();
         }
 
         ch.mode = params.mode;
         ch.fee = params.fee;
-        ch.reward = params.reward;
 
         emit ChannelUpdated(params.paraID);
     }
@@ -408,7 +424,7 @@ contract Gateway is IGateway, IInitializable {
 
     // Register a token on AssetHub
     function registerToken(address token) external payable {
-        (bytes memory payload, uint256 extraFee) = Assets.registerToken(token, CREATE_TOKEN_CALL_ID);
+        (bytes memory payload, uint256 extraFee) = Assets.registerToken(token);
 
         _submitOutbound(ASSET_HUB_PARA_ID, payload, extraFee);
     }
@@ -529,14 +545,13 @@ contract Gateway is IGateway, IInitializable {
             revert Unauthorized();
         }
 
-        (uint256 defaultFee, uint256 defaultReward, uint256 registerTokenFee, uint256 sendTokenFee) =
-            abi.decode(data, (uint256, uint256, uint256, uint256));
+        (uint256 defaultFee, uint256 registerTokenFee, uint256 sendTokenFee) =
+            abi.decode(data, (uint256, uint256, uint256));
 
         CoreStorage.Layout storage $ = CoreStorage.layout();
 
         $.mode = OperatingMode.Normal;
         $.defaultFee = defaultFee;
-        $.defaultReward = defaultReward;
 
         // Initialize an agent & channel for BridgeHub
         address bridgeHubAgent = address(new Agent(BRIDGE_HUB_AGENT_ID));
@@ -546,8 +561,7 @@ contract Gateway is IGateway, IInitializable {
             agent: bridgeHubAgent,
             inboundNonce: 0,
             outboundNonce: 0,
-            fee: defaultFee,
-            reward: defaultReward
+            fee: defaultFee
         });
 
         // Initialize an agent & channel for AssetHub
@@ -558,8 +572,7 @@ contract Gateway is IGateway, IInitializable {
             agent: assetHubAgent,
             inboundNonce: 0,
             outboundNonce: 0,
-            fee: defaultFee,
-            reward: defaultReward
+            fee: defaultFee
         });
 
         Assets.initialize(registerTokenFee, sendTokenFee);

contracts/src/SubstrateTypes.sol

@@ -56,18 +56,13 @@ library SubstrateTypes {
      * `NativeTokensMessage::Create`
      */
     // solhint-disable-next-line func-name-mixedcase
-    function RegisterToken(address gateway, address token, bytes2 createCallIndex)
-        internal
-        view
-        returns (bytes memory)
-    {
+    function RegisterToken(address gateway, address token) internal view returns (bytes memory) {
         return bytes.concat(
             bytes1(0x00),
             ScaleCodec.encodeU64(uint64(block.chainid)),
             bytes1(0x00),
             SubstrateTypes.H160(gateway),
-            SubstrateTypes.H160(token),
-            createCallIndex
+            SubstrateTypes.H160(token)
         );
     }