Standard cross-chain gateways and Axelar adapters (#9)

Author: ernestognw

.github/workflows/checks.yml

@@ -33,6 +33,8 @@ jobs:
       GAS: true
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - name: Set up environment
         uses: ./.github/actions/setup
       - name: Run tests and generate gas report
@@ -42,6 +44,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - name: Set up environment
         uses: ./.github/actions/setup
       - name: Run coverage
@@ -62,6 +66,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - name: Set up environment
         uses: ./.github/actions/setup
       - run: rm foundry.toml

contracts/crosschain/axelar/AxelarGatewayBase.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";
+
+/**
+ * @dev Base implementation of a cross-chain gateway adapter for the Axelar Network.
+ *
+ * This contract allows developers to register equivalence between chains (i.e. CAIP-2 chain identifiers
+ * to Axelar chain identifiers) and remote gateways (i.e. gateways on other chains) to
+ * facilitate cross-chain communication.
+ */
+abstract contract AxelarGatewayBase is Ownable {
+    /// @dev A remote gateway has been registered for a chain.
+    event RegisteredRemoteGateway(string caip2, string gatewayAddress);
+
+    /// @dev A chain equivalence has been registered.
+    event RegisteredChainEquivalence(string caip2, string destinationChain);
+
+    /// @dev Error emitted when an unsupported chain is queried.
+    error UnsupportedChain(string caip2);
+
+    /// @dev Axelar's official gateway for the current chain.
+    IAxelarGateway public immutable localGateway;
+
+    mapping(string caip2 => string remoteGateway) private _remoteGateways;
+    mapping(string caip2OrAxelar => string axelarOrCaip2) private _chainEquivalence;
+
+    /// @dev Sets the local gateway address (i.e. Axelar's official gateway for the current chain).
+    constructor(IAxelarGateway _gateway) {
+        localGateway = _gateway;
+    }
+
+    /// @dev Returns the equivalent chain given an id that can be either CAIP-2 or an Axelar network identifier.
+    function getEquivalentChain(string memory input) public view virtual returns (string memory output) {
+        output = _chainEquivalence[input];
+        require(bytes(output).length > 0, UnsupportedChain(input));
+    }
+
+    /// @dev Returns the remote gateway address for a given chain.
+    function getRemoteGateway(string memory caip2) public view virtual returns (string memory remoteGateway) {
+        remoteGateway = _remoteGateways[caip2];
+        require(bytes(remoteGateway).length > 0, UnsupportedChain(caip2));
+    }
+
+    /// @dev Registers a chain equivalence between a CAIP-2 chain identifier and an Axelar network identifier.
+    function registerChainEquivalence(string calldata caip2, string calldata axelarSupported) public virtual onlyOwner {
+        require(bytes(_chainEquivalence[caip2]).length == 0);
+        _chainEquivalence[caip2] = axelarSupported;
+        _chainEquivalence[axelarSupported] = caip2;
+        emit RegisteredChainEquivalence(caip2, axelarSupported);
+    }
+
+    /// @dev Registers a remote gateway address for a given CAIP-2 chain identifier.
+    function registerRemoteGateway(string calldata caip2, string calldata remoteGateway) public virtual onlyOwner {
+        require(bytes(_remoteGateways[caip2]).length == 0);
+        _remoteGateways[caip2] = remoteGateway;
+        emit RegisteredRemoteGateway(caip2, remoteGateway);
+    }
+}

contracts/crosschain/axelar/AxelarGatewayDestination.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
+import {CAIP2} from "@openzeppelin/contracts@master/utils/CAIP2.sol";
+import {CAIP10} from "@openzeppelin/contracts@master/utils/CAIP10.sol";
+import {Strings} from "@openzeppelin/contracts@master/utils/Strings.sol";
+import {IERC7786GatewayDestinationPassive, IERC7786Receiver} from "../interfaces/draft-IERC7786.sol";
+import {AxelarGatewayBase} from "./AxelarGatewayBase.sol";
+
+/**
+ * @dev Implementation of an ERC7786 gateway destination adapter for the Axelar Network in dual mode.
+ *
+ * The contract implements implements AxelarExecutable's {_execute} function to execute the message,
+ * converting Axelar's native workflow into the standard ERC7786 active mode.
+ * Alternatively, it provides a way to set a message as executed by calling the {setExecutedMessage}
+ * function (passive mode).
+ */
+abstract contract AxelarGatewayDestination is IERC7786GatewayDestinationPassive, AxelarGatewayBase, AxelarExecutable {
+    using Strings for address;
+    using Strings for string;
+
+    /// @dev Sets a message as executed so it can't be executed again. Should be called by the receiver contract.
+    function setExecutedMessage(
+        bytes calldata messageKey,
+        string calldata source, // CAIP-2
+        string calldata sender, // CAIP-10
+        bytes calldata payload,
+        bytes[] calldata attributes
+    ) external {
+        // Extract Axelar commandId
+        bytes32 commandId = abi.decode(messageKey, (bytes32));
+
+        // Rebuild expected package
+        bytes memory adapterPayload = abi.encode(
+            sender,
+            msg.sender.toChecksumHexString(), // receiver
+            payload,
+            attributes
+        );
+
+        // Check package was received from remote gateway on src chain
+        require(
+            gateway.validateContractCall(
+                commandId,
+                getEquivalentChain(source),
+                getRemoteGateway(source),
+                keccak256(adapterPayload)
+            ),
+            NotApprovedByGateway()
+        );
+    }
+
+    /**
+     * @dev Active mode execution of a cross-chain message.
+     *
+     * In this function:
+     *
+     * - `remoteChain` is in the Axelar format. It should not be expected to be a proper CAIP-2 format
+     * - `remoteAccount` is the sender of the crosschain message. That should be the remote gateway on the chain which
+     *   the message originates from. It is NOT the sender of the crosschain message
+     *
+     * Proper CAIP-10 encoding of the message sender (including the CAIP-2 name of the origin chain can be found in
+     * the message)
+     */
+    function _execute(
+        string calldata remoteChain, // chain of the remote gateway - axelar format
+        string calldata remoteAccount, // address of the remote gateway
+        bytes calldata adapterPayload
+    ) internal override {
+        // Parse the package
+        (string memory sender, string memory receiver, bytes memory payload, bytes[] memory attributes) = abi.decode(
+            adapterPayload,
+            (string, string, bytes, bytes[])
+        );
+        string memory source = getEquivalentChain(remoteChain);
+
+        // check message validity
+        // - `remoteAccount` is the remote gateway on the origin chain.
+        require(getRemoteGateway(source).equal(remoteAccount), "Invalid origin gateway");
+
+        // Active mode
+        IERC7786Receiver(receiver.parseAddress()).receiveMessage(
+            address(0), // not needed in active mode
+            new bytes(0), // not needed in active mode
+            source,
+            sender,
+            payload,
+            attributes
+        );
+    }
+}

contracts/crosschain/axelar/AxelarGatewaySource.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {CAIP2} from "@openzeppelin/contracts@master/utils/CAIP2.sol";
+import {CAIP10} from "@openzeppelin/contracts@master/utils/CAIP10.sol";
+import {Strings} from "@openzeppelin/contracts@master/utils/Strings.sol";
+import {AxelarGatewayBase} from "./AxelarGatewayBase.sol";
+import {IERC7786GatewaySource} from "../interfaces/draft-IERC7786.sol";
+
+/**
+ * @dev Implementation of an ERC7786 gateway source adapter for the Axelar Network.
+ *
+ * The contract provides a way to send messages to a remote chain using the Axelar Network
+ * using the {sendMessage} function.
+ */
+abstract contract AxelarGatewaySource is IERC7786GatewaySource, AxelarGatewayBase {
+    using Strings for address;
+
+    /// @inheritdoc IERC7786GatewaySource
+    function supportsAttribute(bytes4 /*selector*/) public pure returns (bool) {
+        return false;
+    }
+
+    /// @inheritdoc IERC7786GatewaySource
+    function sendMessage(
+        string calldata destination, // CAIP-2 chain ID
+        string calldata receiver, // i.e. address
+        bytes calldata payload,
+        bytes[] calldata attributes
+    ) external payable returns (bytes32) {
+        require(msg.value == 0, "Value not supported");
+        if (attributes.length > 0) revert UnsupportedAttribute(bytes4(attributes[0][0:4]));
+
+        // Create the package
+        string memory sender = msg.sender.toChecksumHexString();
+        bytes memory adapterPayload = abi.encode(sender, receiver, payload, attributes);
+
+        // Emit event
+        emit MessageCreated(
+            0,
+            CAIP10.format(CAIP2.local(), sender),
+            CAIP10.format(destination, receiver),
+            payload,
+            attributes
+        );
+
+        // Send the message
+        string memory axelarDestination = getEquivalentChain(destination);
+        string memory remoteGateway = getRemoteGateway(destination);
+        localGateway.callContract(axelarDestination, remoteGateway, adapterPayload);
+
+        return 0;
+    }
+}

contracts/crosschain/axelar/mocks/AxelarGatewayMock.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {IAxelarGateway} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarGateway.sol";
+import {IAxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IAxelarExecutable.sol";
+import {BitMaps} from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
+import {Strings} from "@openzeppelin/contracts@master/utils/Strings.sol";
+
+contract AxelarGatewayMock {
+    using Strings for address;
+    using Strings for string;
+    using BitMaps for BitMaps.BitMap;
+
+    bool private activeMode;
+    BitMaps.BitMap private pendingCommandIds;
+
+    event CommandIdPending(
+        bytes32 indexed commandId,
+        string destinationChain,
+        string destinationContractAddress,
+        bytes payload
+    );
+
+    function setActive(bool enabled) public {
+        activeMode = enabled;
+    }
+
+    function callContract(
+        string calldata destinationChain,
+        string calldata destinationContractAddress,
+        bytes calldata payload
+    ) external {
+        // TODO: check that destination chain is local
+
+        emit IAxelarGateway.ContractCall(
+            msg.sender,
+            destinationChain,
+            destinationContractAddress,
+            keccak256(payload),
+            payload
+        );
+
+        bytes32 commandId = keccak256(
+            abi.encode(
+                destinationChain,
+                msg.sender.toChecksumHexString(),
+                destinationContractAddress,
+                keccak256(payload)
+            )
+        );
+
+        require(!pendingCommandIds.get(uint256(commandId)));
+        pendingCommandIds.set(uint256(commandId));
+
+        emit CommandIdPending(commandId, destinationChain, destinationContractAddress, payload);
+
+        if (activeMode) {
+            // NOTE:
+            // - source chain and destination chain are the same in this mock
+            address target = destinationContractAddress.parseAddress();
+            IAxelarExecutable(target).execute(commandId, destinationChain, msg.sender.toChecksumHexString(), payload);
+        }
+    }
+
+    function validateContractCall(
+        bytes32 commandId,
+        string calldata sourceChain,
+        string calldata sourceAddress,
+        bytes32 payloadHash
+    ) external returns (bool) {
+        if (pendingCommandIds.get(uint256(commandId))) {
+            pendingCommandIds.unset(uint256(commandId));
+
+            emit IAxelarGateway.ContractCallExecuted(commandId);
+
+            return
+                commandId ==
+                keccak256(abi.encode(sourceChain, sourceAddress, msg.sender.toChecksumHexString(), payloadHash));
+        } else return false;
+    }
+}