add/move files that are no longer planned to be in the main repo

Author: Amxx

contracts/crosschain/axelar/AxelarGatewayDestination.sol

@@ -6,9 +6,8 @@ import {AxelarExecutable} from "@axelar-network/axelar-gmp-sdk-solidity/contract
 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";
-// import {IERC7786GatewayDestinationPassive, IERC7786Receiver} from "@openzeppelin/contracts@master/interfaces/IERC7786.sol";
-import {IERC7786GatewayDestinationPassive, IERC7786Receiver} from "../vendor/draft-IERC7786.sol";
 
 abstract contract AxelarGatewayDestination is IERC7786GatewayDestinationPassive, AxelarGatewayBase, AxelarExecutable {
     using Strings for address;

contracts/crosschain/axelar/AxelarGatewaySource.sol

@@ -6,8 +6,7 @@ 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 "@openzeppelin/contracts@master/interfaces/IERC7786.sol";
-import {IERC7786GatewaySource} from "../vendor/draft-IERC7786.sol";
+import {IERC7786GatewaySource} from "../interfaces/draft-IERC7786.sol";
 
 abstract contract AxelarGatewaySource is IERC7786GatewaySource, AxelarGatewayBase {
     using Strings for address;

contracts/crosschain/mocks/AxelarGatewayMock.sol renamed to contracts/crosschain/axelar/mocks/AxelarGatewayMock.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {BitMaps} from "@openzeppelin/contracts@master/utils/structs/BitMaps.sol";
+import {Strings} from "@openzeppelin/contracts@master/utils/Strings.sol";
+import {CAIP2} from "@openzeppelin/contracts@master/utils/CAIP2.sol";
+import {CAIP10} from "@openzeppelin/contracts@master/utils/CAIP10.sol";
+import {IERC7786GatewaySource, IERC7786GatewayDestinationPassive, IERC7786Receiver} from "../interfaces/draft-IERC7786.sol";
+
+contract ERC7786GatewayMock is IERC7786GatewaySource, IERC7786GatewayDestinationPassive {
+    using BitMaps for BitMaps.BitMap;
+    using Strings for *;
+
+    BitMaps.BitMap private _outbox;
+    bool private _activeMode;
+
+    function _setActive(bool newActiveMode) internal {
+        _activeMode = newActiveMode;
+    }
+
+    function supportsAttribute(bytes4 /*selector*/) public pure returns (bool) {
+        return false;
+    }
+
+    function sendMessage(
+        string calldata destination, // CAIP-2 chain ID
+        string calldata receiver, // CAIP-10 account ID
+        bytes calldata payload,
+        bytes[] calldata attributes
+    ) public payable returns (bytes32) {
+        string memory source = CAIP2.local();
+        string memory sender = msg.sender.toChecksumHexString();
+
+        require(destination.equal(source), "This mock only supports local messages");
+        for (uint256 i = 0; i < attributes.length; ++i) {
+            bytes4 selector = bytes4(attributes[i][0:4]);
+            if (!supportsAttribute(selector)) revert UnsupportedAttribute(selector);
+        }
+
+        if (_activeMode) {
+            address target = Strings.parseAddress(receiver);
+            IERC7786Receiver(target).receiveMessage(address(this), new bytes(0), source, sender, payload, attributes);
+        } else {
+            _outbox.set(uint256(keccak256(abi.encode(source, sender, receiver, payload, attributes))));
+        }
+
+        emit MessageCreated(0, CAIP10.format(source, sender), CAIP10.format(source, receiver), payload, attributes);
+        return 0;
+    }
+
+    function validateReceivedMessage(
+        bytes calldata /*messageKey*/, // this mock doesn't use a messageKey
+        string calldata source,
+        string calldata sender,
+        bytes calldata payload,
+        bytes[] calldata attributes
+    ) public {
+        uint256 digest = uint256(
+            keccak256(abi.encode(source, sender, msg.sender.toChecksumHexString(), payload, attributes))
+        );
+        require(_outbox.get(digest), "invalid message");
+        _outbox.unset(digest);
+    }
+}

contracts/crosschain/vendor/draft-IERC7786.sol renamed to contracts/crosschain/interfaces/draft-IERC7786.sol

@@ -1,20 +1,20 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity ^0.8.27;
+pragma solidity ^0.8.0;
 
-import {ERC7786Receiver} from "../vendor/draft-ERC7786Receiver.sol";
+import {ERC7786Receiver} from "../utils/draft-ERC7786Receiver.sol";
 
 contract ERC7786ReceiverMock is ERC7786Receiver {
-    address public immutable GATEWAY;
+    address private immutable _gateway;
 
     event MessageReceived(address gateway, string source, string sender, bytes payload, bytes[] attributes);
 
-    constructor(address _gateway) {
-        GATEWAY = _gateway;
+    constructor(address gateway_) {
+        _gateway = gateway_;
     }
 
     function _isKnownGateway(address instance) internal view virtual override returns (bool) {
-        return instance == GATEWAY;
+        return instance == _gateway;
     }
 
     function _processMessage(

contracts/crosschain/mocks/ERC7786GatewayMock.sol

@@ -2,7 +2,7 @@
 
 pragma solidity ^0.8.0;
 
-import {IERC7786GatewayDestinationPassive, IERC7786Receiver} from "./draft-IERC7786.sol";
+import {IERC7786GatewayDestinationPassive, IERC7786Receiver} from "../interfaces/draft-IERC7786.sol";
 
 /**
  * @dev Base implementation of an ERC-7786 compliant cross-chain message receiver.

contracts/crosschain/mocks/ERC7786ReceiverMock.sol

@@ -0,0 +1,85 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { getLocalCAIP } = require('../helpers/chains');
+const payload = require('../helpers/random').generators.hexBytes(128);
+const attributes = [];
+
+const getAddress = account => ethers.getAddress(account.target ?? account.address ?? account);
+
+async function fixture() {
+  const [sender, notAGateway] = await ethers.getSigners();
+  const { caip2, toCaip10 } = await getLocalCAIP();
+
+  const gateway = await ethers.deployContract('$ERC7786GatewayMock');
+  const receiver = await ethers.deployContract('$ERC7786ReceiverMock', [gateway]);
+
+  return { sender, notAGateway, gateway, receiver, caip2, toCaip10 };
+}
+
+// NOTE: here we are only testing the receiver. Failures of the gateway itself (invalid attributes, ...) are out of scope.
+describe('ERC7786Receiver', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('active mode', function () {
+    beforeEach(async function () {
+      await this.gateway.$_setActive(true);
+    });
+
+    it('nominal workflow', async function () {
+      await expect(this.gateway.connect(this.sender).sendMessage(this.caip2, getAddress(this.receiver), payload, attributes))
+        .to.emit(this.gateway, 'MessageCreated')
+        .withArgs(ethers.ZeroHash, this.toCaip10(this.sender), this.toCaip10(this.receiver), payload, attributes)
+        .to.emit(this.receiver, 'MessageReceived')
+        .withArgs(this.gateway, this.caip2, getAddress(this.sender), payload, attributes);
+    });
+  });
+
+  describe('passive mode', function () {
+    beforeEach(async function () {
+      await this.gateway.$_setActive(false);
+    });
+
+    it('nominal workflow', async function () {
+      await expect(this.gateway.connect(this.sender).sendMessage(this.caip2, this.receiver.target, payload, attributes))
+        .to.emit(this.gateway, 'MessageCreated')
+        .withArgs(ethers.ZeroHash, this.toCaip10(this.sender), this.toCaip10(this.receiver), payload, attributes)
+        .to.not.emit(this.receiver, 'MessageReceived');
+
+      await expect(
+        this.receiver.receiveMessage(this.gateway, '0x', this.caip2, getAddress(this.sender), payload, attributes),
+      )
+        .to.emit(this.receiver, 'MessageReceived')
+        .withArgs(this.gateway, this.caip2, getAddress(this.sender), payload, attributes);
+    });
+
+    it('invalid message', async function () {
+      await this.gateway.connect(this.sender).sendMessage(this.caip2, this.receiver.target, payload, attributes);
+
+      // Altering the message (in this case, changing the sender's address)
+      // Here the error is actually triggered by the gateway itself.
+      await expect(
+        this.receiver.receiveMessage(this.gateway, '0x', this.caip2, getAddress(this.notAGateway), payload, attributes),
+      ).to.be.revertedWith('invalid message');
+    });
+
+    it('invalid gateway', async function () {
+      await expect(
+        this.receiver.receiveMessage(this.notAGateway, '0x', this.caip2, getAddress(this.sender), payload, attributes),
+      )
+        .to.be.revertedWithCustomError(this.receiver, 'ERC7786ReceiverInvalidGateway')
+        .withArgs(this.notAGateway);
+    });
+
+    it('with value', async function () {
+      await expect(
+        this.receiver.receiveMessage(this.gateway, '0x', this.caip2, getAddress(this.sender), payload, attributes, {
+          value: 1n,
+        }),
+      ).to.be.revertedWithCustomError(this.receiver, 'ERC7786ReceivePassiveModeValue');
+    });
+  });
+});

contracts/crosschain/vendor/draft-ERC7786Receiver.sol renamed to contracts/crosschain/utils/draft-ERC7786Receiver.sol

@@ -0,0 +1,109 @@
+// NOTE: this file defines some examples of CAIP-2 and CAIP-10 identifiers.
+// The following listing does not pretend to be exhaustive or even accurate. It SHOULD NOT be used in production.
+
+const { ethers } = require('hardhat');
+const { mapValues } = require('./iterate');
+
+// EVM (https://axelarscan.io/resources/chains?type=evm)
+const ethereum = {
+  Ethereum: '1',
+  optimism: '10',
+  binance: '56',
+  Polygon: '137',
+  Fantom: '250',
+  fraxtal: '252',
+  filecoin: '314',
+  Moonbeam: '1284',
+  centrifuge: '2031',
+  kava: '2222',
+  mantle: '5000',
+  base: '8453',
+  immutable: '13371',
+  arbitrum: '42161',
+  celo: '42220',
+  Avalanche: '43114',
+  linea: '59144',
+  blast: '81457',
+  scroll: '534352',
+  aurora: '1313161554',
+};
+
+// Cosmos (https://axelarscan.io/resources/chains?type=cosmos)
+const cosmos = {
+  Axelarnet: 'axelar-dojo-1',
+  osmosis: 'osmosis-1',
+  cosmoshub: 'cosmoshub-4',
+  juno: 'juno-1',
+  'e-money': 'emoney-3',
+  injective: 'injective-1',
+  crescent: 'crescent-1',
+  kujira: 'kaiyo-1',
+  'secret-snip': 'secret-4',
+  secret: 'secret-4',
+  sei: 'pacific-1',
+  stargaze: 'stargaze-1',
+  assetmantle: 'mantle-1',
+  fetch: 'fetchhub-4',
+  ki: 'kichain-2',
+  evmos: 'evmos_9001-2',
+  aura: 'xstaxy-1',
+  comdex: 'comdex-1',
+  persistence: 'core-1',
+  regen: 'regen-1',
+  umee: 'umee-1',
+  agoric: 'agoric-3',
+  xpla: 'dimension_37-1',
+  acre: 'acre_9052-1',
+  stride: 'stride-1',
+  carbon: 'carbon-1',
+  sommelier: 'sommelier-3',
+  neutron: 'neutron-1',
+  rebus: 'reb_1111-1',
+  archway: 'archway-1',
+  provenance: 'pio-mainnet-1',
+  ixo: 'ixo-5',
+  migaloo: 'migaloo-1',
+  teritori: 'teritori-1',
+  haqq: 'haqq_11235-1',
+  celestia: 'celestia',
+  ojo: 'agamotto',
+  chihuahua: 'chihuahua-1',
+  saga: 'ssc-1',
+  dymension: 'dymension_1100-1',
+  fxcore: 'fxcore',
+  c4e: 'perun-1',
+  bitsong: 'bitsong-2b',
+  nolus: 'pirin-1',
+  lava: 'lava-mainnet-1',
+  'terra-2': 'phoenix-1',
+  terra: 'columbus-5',
+};
+
+const makeCAIP = ({ namespace, reference, account }) => ({
+  namespace,
+  reference,
+  account,
+  caip2: `${namespace}:${reference}`,
+  caip10: `${namespace}:${reference}:${account}`,
+  toCaip10: other => `${namespace}:${reference}:${ethers.getAddress(other.target ?? other.address ?? other)}`,
+});
+
+module.exports = {
+  CHAINS: mapValues(
+    Object.assign(
+      mapValues(ethereum, reference => ({
+        namespace: 'eip155',
+        reference,
+        account: ethers.Wallet.createRandom().address,
+      })),
+      mapValues(cosmos, reference => ({
+        namespace: 'cosmos',
+        reference,
+        account: ethers.encodeBase58(ethers.randomBytes(32)),
+      })),
+    ),
+    makeCAIP,
+  ),
+  getLocalCAIP: account =>
+    ethers.provider.getNetwork().then(({ chainId }) => makeCAIP({ namespace: 'eip155', reference: chainId, account })),
+};

test/crosschain/ERC7786Receiver.test.js

@@ -0,0 +1,36 @@
+module.exports = {
+  // ================================================= Array helpers =================================================
+
+  // Cut an array into an array of sized-length arrays
+  // Example: chunk([1,2,3,4,5,6,7,8], 3) → [[1,2,3],[4,5,6],[7,8]]
+  chunk: (array, size = 1) =>
+    Array.from({ length: Math.ceil(array.length / size) }, (_, i) => array.slice(i * size, i * size + size)),
+
+  // Cartesian cross product of an array of arrays
+  // Example: product([1,2],[a,b,c],[true]) → [[1,a,true],[1,b,true],[1,c,true],[2,a,true],[2,b,true],[2,c,true]]
+  product: (...arrays) => arrays.reduce((a, b) => a.flatMap(ai => b.map(bi => [...ai, bi])), [[]]),
+
+  // Range from start to end in increment
+  // Example: range(17,42,7) → [17,24,31,38]
+  range: (start, stop = undefined, step = 1) => {
+    if (stop == undefined) {
+      stop = start;
+      start = 0;
+    }
+    return start < stop ? Array.from({ length: (stop - start + step - 1) / step }, (_, i) => start + i * step) : [];
+  },
+
+  // Unique elements, with an optional getter function
+  // Example: unique([1,1,2,3,4,8,1,3,8,13,42]) → [1,2,3,4,8,13,42]
+  unique: (array, op = x => x) => array.filter((obj, i) => array.findIndex(entry => op(obj) === op(entry)) === i),
+
+  // Zip arrays together. If some arrays are smaller, undefined is used as a filler.
+  // Example: zip([1,2],[a,b,c],[true]) → [[1,a,true],[2,b,undefined],[undefined,c,undefined]]
+  zip: (...args) => Array.from({ length: Math.max(...args.map(arg => arg.length)) }, (_, i) => args.map(arg => arg[i])),
+
+  // ================================================ Object helpers =================================================
+
+  // Create a new object by mapping the values through a function, keeping the keys
+  // Example: mapValues({a:1,b:2,c:3}, x => x**2) → {a:1,b:4,c:9}
+  mapValues: (obj, fn) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)])),
+};