update

Author: Amxx

contracts/crosschain/ICAIP2Equivalence.sol

@@ -4,36 +4,40 @@ 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";
-import {ICAIP2Equivalence} from "../ICAIP2Equivalence.sol";
 
-abstract contract AxelarGatewayBase is ICAIP2Equivalence, Ownable {
+abstract contract AxelarGatewayBase is Ownable {
     event RegisteredRemoteGateway(string caip2, string gatewayAddress);
     event RegisteredCAIP2Equivalence(string caip2, string destinationChain);
 
+    error UnsupportedChain(string caip2);
+
     IAxelarGateway public immutable localGateway;
 
+    // TODO: merge these two (and the corresponding setters?)
     mapping(string caip2 => string remoteGateway) private _remoteGateways;
     mapping(string caip2 => string destinationChain) private _equivalence;
 
     constructor(IAxelarGateway _gateway) {
         localGateway = _gateway;
     }
 
-    function fromCAIP2(string memory caip2) public view returns (string memory) {
-        return _equivalence[caip2];
+    function fromCAIP2(string memory caip2) public view virtual returns (string memory axelarName) {
+        axelarName = _equivalence[caip2];
+        require(bytes(axelarName).length > 0, UnsupportedChain(caip2));
     }
 
-    function getRemoteGateway(string memory caip2) public view returns (string memory remoteGateway) {
-        return _remoteGateways[caip2];
+    function getRemoteGateway(string memory caip2) public view virtual returns (string memory remoteGateway) {
+        remoteGateway = _remoteGateways[caip2];
+        require(bytes(remoteGateway).length > 0, UnsupportedChain(caip2));
     }
 
-    function registerCAIP2Equivalence(string calldata caip2, string calldata axelarSupported) public onlyOwner {
+    function registerCAIP2Equivalence(string calldata caip2, string calldata axelarSupported) public virtual onlyOwner {
         require(bytes(_equivalence[caip2]).length == 0);
         _equivalence[caip2] = axelarSupported;
         emit RegisteredCAIP2Equivalence(caip2, axelarSupported);
     }
 
-    function registerRemoteGateway(string calldata caip2, string calldata remoteGateway) public onlyOwner {
+    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/IGatewaySource.sol

@@ -5,42 +5,37 @@ pragma solidity ^0.8.27;
 import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contracts/executable/AxelarExecutable.sol";
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {StringsUnreleased} from "../../utils/Strings.sol";
-import {AxelarGatewayBase} from "./AxelarGatewayBase.sol";
-import {IGatewayDestinationPassive} from "../IGatewayDestinationPassive.sol";
-import {IGatewayReceiver} from "../IGatewayReceiver.sol";
 import {CAIP2} from "../../utils/CAIP-2.sol";
 import {CAIP10} from "../../utils/CAIP-10.sol";
+import {AxelarGatewayBase} from "./AxelarGatewayBase.sol";
+import {IGatewayDestinationPassive} from "../interfaces/IGatewayDestinationPassive.sol";
+import {IGatewayReceiver} from "../interfaces/IGatewayReceiver.sol";
 
 abstract contract AxelarGatewayDestination is IGatewayDestinationPassive, AxelarGatewayBase, AxelarExecutable {
     using Strings for string;
 
     /// @dev Passive mode
     function validateReceivedMessage(
-        bytes calldata gatewayData,
-        string calldata srcChain, // CAIP-2
-        string calldata srcAccount, // CAIP-10
+        bytes calldata messageKey,
+        string calldata source, // CAIP-2
+        string calldata sender, // CAIP-10
         bytes calldata payload,
         bytes[] calldata attributes
-    ) external virtual override {
+    ) external virtual {
         // Extract Axelar commandId
-        bytes32 commandId = abi.decode(gatewayData, (bytes32));
+        bytes32 commandId = abi.decode(messageKey, (bytes32));
 
         // Rebuild expected package
         bytes memory package = abi.encode(
-            CAIP10.format(srcChain, srcAccount),
+            CAIP10.format(source, sender),
             CAIP10.format(msg.sender),
             payload,
             attributes
         );
 
         // Check package was received from remote gateway on src chain
         require(
-            gateway.validateContractCall(
-                commandId,
-                fromCAIP2(srcChain),
-                getRemoteGateway(srcChain),
-                keccak256(package)
-            ),
+            gateway.validateContractCall(commandId, fromCAIP2(source), getRemoteGateway(source), keccak256(package)),
             NotApprovedByGateway()
         );
     }
@@ -59,27 +54,28 @@ abstract contract AxelarGatewayDestination is IGatewayDestinationPassive, Axelar
         bytes calldata package
     ) internal virtual override {
         // Parse the package
-        (string memory srcCAIP10, string memory dstCAIP10, bytes memory payload, bytes[] memory attributes) = abi
-            .decode(package, (string, string, bytes, bytes[]));
+        (string memory from, string memory to, bytes memory payload, bytes[] memory attributes) = abi.decode(
+            package,
+            (string, string, bytes, bytes[])
+        );
 
-        (string memory srcChain, string memory srcAccount) = CAIP10.parse(srcCAIP10);
-        (string memory dstChain, string memory dstAccount) = CAIP10.parse(dstCAIP10);
+        (string memory source, string memory sender) = CAIP10.parse(from);
+        (string memory destination, string memory receiver) = CAIP10.parse(to);
 
         // check message validity
         // - `remoteChain` matches origin chain in the message (in caip2)
         // - `remoteAccount` is the remote gateway on the origin chain.
-        require(remoteChain.equal(fromCAIP2(srcChain)), "Invalid origin chain");
-        require(remoteAccount.equal(getRemoteGateway(srcChain)), "Invalid origin gateway");
+        require(remoteChain.equal(fromCAIP2(source)), "Invalid origin chain");
+        require(remoteAccount.equal(getRemoteGateway(source)), "Invalid origin gateway");
         // This check is not required for security. That is enforced by axelar (+ source gateway)
-        require(dstChain.equal(CAIP2.format()), "Invalid tardet chain");
+        require(destination.equal(CAIP2.format()), "Invalid tardet chain");
 
         // Active mode
-        address destination = StringsUnreleased.parseAddress(dstAccount);
-        IGatewayReceiver(destination).receiveMessage(
+        IGatewayReceiver(StringsUnreleased.parseAddress(receiver)).receiveMessage(
             address(0), // not needed in active mode
             new bytes(0), // not needed in active mode
-            srcChain,
-            srcAccount,
+            source,
+            sender,
             payload,
             attributes
         );

contracts/crosschain/axelar/AxelarGatewayBase.sol

@@ -3,30 +3,38 @@
 pragma solidity ^0.8.27;
 
 import {AxelarGatewayBase} from "./AxelarGatewayBase.sol";
-import {IGatewaySource} from "../IGatewaySource.sol";
+import {IGatewaySource} from "../interfaces/IGatewaySource.sol";
 import {CAIP10} from "../../utils/CAIP-10.sol";
 
 abstract contract AxelarGatewaySource is IGatewaySource, AxelarGatewayBase {
+    function supportsAttribute(bytes4 /*signature*/) public view virtual returns (bool) {
+        return false;
+    }
+
     function sendMessage(
-        string calldata dstChain, // CAIP-2 chain ID
-        string calldata dstAccount, // i.e. address
+        string calldata destination, // CAIP-2 chain ID
+        string calldata receiver, // i.e. address
         bytes calldata payload,
         bytes[] calldata attributes
-    ) external payable override returns (bytes32) {
-        // TODO: Handle ether (payable)
-        // TODO: Validate attributes
+    ) external payable virtual returns (bytes32) {
+        // TODO: add support for value and attributes ?
+        require(msg.value == 0, "Value not supported");
+        for (uint256 i = 0; i < attributes.length; ++i) {
+            bytes4 signature = bytes4(attributes[i][0:4]);
+            require(supportsAttribute(signature), UnsuportedAttribute(signature));
+        }
 
-        string memory srcCAIP10 = CAIP10.format(msg.sender);
-        string memory dstCAIP10 = CAIP10.format(dstChain, dstAccount);
+        string memory from = CAIP10.format(msg.sender);
+        string memory to = CAIP10.format(destination, receiver);
 
         // Create the package
-        bytes memory package = abi.encode(srcCAIP10, dstCAIP10, payload, attributes);
+        bytes memory package = abi.encode(from, to, payload, attributes);
 
         // Emit event
-        emit MessageCreated(0, srcCAIP10, dstCAIP10, payload, attributes);
+        emit MessageCreated(0, from, to, payload, attributes);
 
         // Send the message
-        localGateway.callContract(fromCAIP2(dstChain), getRemoteGateway(dstChain), package);
+        localGateway.callContract(fromCAIP2(destination), getRemoteGateway(destination), package);
 
         return 0;
     }

contracts/crosschain/axelar/AxelarGatewayDestination.sol

@@ -3,12 +3,12 @@
 pragma solidity ^0.8.0;
 
 interface IGatewayDestinationPassive {
-    error GatewayDestinationPassiveInvalidMessage(bytes gatewayData);
+    error InvalidMessageKey(bytes messageKey);
 
     function validateReceivedMessage(
-        bytes calldata gatewayData,
-        string calldata srcChain,
-        string calldata srcAccount,
+        bytes calldata messageKey,
+        string calldata source,
+        string calldata sender,
         bytes calldata payload,
         bytes[] calldata attributes
     ) external;

contracts/crosschain/axelar/AxelarGatewaySource.sol

@@ -4,10 +4,10 @@ pragma solidity ^0.8.0;
 
 interface IGatewayReceiver {
     function receiveMessage(
-        address gatewayAddr,
-        bytes calldata gatewayData,
-        string calldata srcChain,
-        string calldata srcAccount,
+        address gateway,
+        bytes calldata gatewayMessageKey,
+        string calldata source,
+        string calldata sender,
         bytes calldata payload,
         bytes[] calldata attributes
     ) external payable;

contracts/crosschain/IGatewayDestinationPassive.sol renamed to contracts/crosschain/interfaces/IGatewayDestinationPassive.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IGatewaySource {
+    event MessageCreated(
+        bytes32 outboxId,
+        string from, // CAIP-10 account ID
+        string to, // CAIP-10 account ID
+        bytes payload,
+        bytes[] attributes
+    );
+
+    event MessageSent(bytes32 indexed outboxId);
+
+    error UnsuportedAttribute(bytes4 signature);
+
+    function supportsAttribute(bytes4 signature) external view returns (bool);
+
+    function sendMessage(
+        string calldata destination, // CAIP-2 chain ID
+        string calldata receiver, // CAIP-10 account ID
+        bytes calldata payload,
+        bytes[] calldata attributes
+    ) external payable returns (bytes32 outboxId);
+}

contracts/crosschain/IGatewayReceiver.sol renamed to contracts/crosschain/interfaces/IGatewayReceiver.sol

@@ -2,8 +2,8 @@
 
 pragma solidity ^0.8.27;
 
-import {IGatewayDestinationPassive} from "../IGatewayDestinationPassive.sol";
-import {IGatewayReceiver} from "../IGatewayReceiver.sol";
+import {IGatewayDestinationPassive} from "../interfaces/IGatewayDestinationPassive.sol";
+import {IGatewayReceiver} from "../interfaces/IGatewayReceiver.sol";
 
 contract GatewayReceiverMock is IGatewayReceiver {
     address public immutable GATEWAY;