workflow testing (active and passive)

Author: Amxx

contracts/crosschain/mocks/AxelarGatewayMock.sol

@@ -8,45 +8,24 @@ import {BitMaps} from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {StringsUnreleased} from "../../utils/Strings.sol";
 
-contract AxelarGatewayActiveMock {
-    using Strings for address;
-
-    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
-        );
-
-        // NOTE:
-        // - no commandId in this mock
-        // - source chain and destination chain are the same in this mock
-        address target = StringsUnreleased.parseAddress(destinationContractAddress);
-        IAxelarExecutable(target).execute(bytes32(0), destinationChain, msg.sender.toHexString(), payload);
-    }
-}
-
-contract AxelarGatewayPassiveMock {
+contract AxelarGatewayMock {
     using Strings for address;
     using BitMaps for BitMaps.BitMap;
 
+    bool private activeMode;
     BitMaps.BitMap private pendingCommandIds;
 
-    event NewCommandId(
+    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,
@@ -69,7 +48,14 @@ contract AxelarGatewayPassiveMock {
         require(!pendingCommandIds.get(uint256(commandId)));
         pendingCommandIds.set(uint256(commandId));
 
-        emit NewCommandId(commandId, destinationChain, destinationContractAddress, payload);
+        emit CommandIdPending(commandId, destinationChain, destinationContractAddress, payload);
+
+        if (activeMode) {
+            // NOTE:
+            // - source chain and destination chain are the same in this mock
+            address target = StringsUnreleased.parseAddress(destinationContractAddress);
+            IAxelarExecutable(target).execute(commandId, destinationChain, msg.sender.toHexString(), payload);
+        }
     }
 
     function validateContractCall(
@@ -81,6 +67,8 @@ contract AxelarGatewayPassiveMock {
         if (pendingCommandIds.get(uint256(commandId))) {
             pendingCommandIds.unset(uint256(commandId));
 
+            emit IAxelarGateway.ContractCallExecuted(commandId);
+
             return
                 commandId == keccak256(abi.encode(sourceChain, sourceAddress, msg.sender.toHexString(), payloadHash));
         } else return false;

test/crosschain/axelar/AxelarGateway.test.js

@@ -0,0 +1,98 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { anyValue } = require('@nomicfoundation/hardhat-chai-matchers/withArgs');
+
+const getAddress = account => (account.target ?? account.address ?? account).toLowerCase();
+
+async function fixture() {
+  const [owner, sender, ...accounts] = await ethers.getSigners();
+
+  const { chainId } = await ethers.provider.getNetwork();
+  const CAIP2 = `eip155:${chainId}`;
+  const asCAIP10 = account => `eip155:${chainId}:${getAddress(account)}`;
+
+  const axelar     = await ethers.deployContract('$AxelarGatewayMock');
+  const srcGateway = await ethers.deployContract('$AxelarGatewaySource', [ owner, axelar ]);
+  const dstGateway = await ethers.deployContract('$AxelarGatewayDestination', [ owner, axelar, axelar ]);
+  const receiver   = await ethers.deployContract('$GatewayReceiverMock', [ dstGateway ]);
+
+  await srcGateway.registerCAIP2Equivalence(CAIP2, 'local');
+  await dstGateway.registerCAIP2Equivalence(CAIP2, 'local');
+  await srcGateway.registerRemoteGateway(CAIP2, getAddress(dstGateway));
+  await dstGateway.registerRemoteGateway(CAIP2, getAddress(srcGateway));
+
+  return { owner, sender, accounts, CAIP2, asCAIP10, axelar, srcGateway, dstGateway, receiver };
+}
+
+describe('AxelarGateway', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('initial setup', async function () {
+    expect(await this.srcGateway.localGateway()).to.equal(this.axelar);
+    expect(await this.srcGateway.fromCAIP2(this.CAIP2)).to.equal('local');
+    expect(await this.srcGateway.getRemoteGateway(this.CAIP2)).to.equal(getAddress(this.dstGateway));
+
+    expect(await this.dstGateway.localGateway()).to.equal(this.axelar);
+    expect(await this.dstGateway.fromCAIP2(this.CAIP2)).to.equal('local');
+    expect(await this.dstGateway.getRemoteGateway(this.CAIP2)).to.equal(getAddress(this.srcGateway));
+  });
+
+  describe('Active mode', function () {
+    beforeEach(async function () {
+      await this.axelar.setActive(true);
+    });
+
+    it('workflow', async function () {
+      const srcCAIP10  = this.asCAIP10(this.sender);
+      const dstCAIP10  = this.asCAIP10(this.receiver);
+      const payload    = ethers.randomBytes(128);
+      const attributes = [];
+      const package    = ethers.AbiCoder.defaultAbiCoder().encode([ 'string', 'string', 'bytes', 'bytes[]' ], [ srcCAIP10, dstCAIP10, payload, attributes ]);
+
+      const tx = await this.srcGateway.connect(this.sender).sendMessage(this.CAIP2, getAddress(this.receiver), payload, attributes);
+      await expect(tx)
+        .to.emit(this.srcGateway, 'MessageCreated').withArgs(ethers.ZeroHash, srcCAIP10, dstCAIP10, payload, attributes)
+        .to.emit(this.axelar, 'ContractCall').withArgs(this.srcGateway, 'local', getAddress(this.dstGateway), ethers.keccak256(package), package)
+        .to.emit(this.axelar, 'ContractCallExecuted').withArgs(anyValue)
+        .to.emit(this.receiver, 'MessageReceived').withArgs(anyValue, this.CAIP2, getAddress(this.sender), payload, attributes);
+    });
+  });
+
+  describe('Passive mode', function () {
+    beforeEach(async function () {
+      await this.axelar.setActive(false);
+    });
+
+    it('workflow', async function () {
+      const srcCAIP10  = this.asCAIP10(this.sender);
+      const dstCAIP10  = this.asCAIP10(this.receiver);
+      const payload    = ethers.randomBytes(128);
+      const attributes = [];
+      const package    = ethers.AbiCoder.defaultAbiCoder().encode([ 'string', 'string', 'bytes', 'bytes[]' ], [ srcCAIP10, dstCAIP10, payload, attributes ]);
+
+      const tx = await this.srcGateway.connect(this.sender).sendMessage(this.CAIP2, getAddress(this.receiver), payload, attributes);
+      await expect(tx)
+        .to.emit(this.srcGateway, 'MessageCreated').withArgs(ethers.ZeroHash, srcCAIP10, dstCAIP10, payload, attributes)
+        .to.emit(this.axelar, 'ContractCall').withArgs(this.srcGateway, 'local', getAddress(this.dstGateway), ethers.keccak256(package), package)
+        .to.emit(this.axelar, 'CommandIdPending').withArgs(anyValue, 'local', getAddress(this.dstGateway), package);
+
+      const { logs } = await tx.wait();
+      const commandIdEvent = logs.find(({ address, topics }) => address == this.axelar.target && topics[0] == this.axelar.interface.getEvent('CommandIdPending').topicHash);
+      const [ commandId ] = this.axelar.interface.decodeEventLog('CommandIdPending', commandIdEvent.data, commandIdEvent.topics);
+
+      await expect(this.receiver.receiveMessage(
+        this.dstGateway,
+        commandId, // bytes32 is already self-encoded
+        this.CAIP2,
+        getAddress(this.sender),
+        payload,
+        attributes,
+      ))
+        .to.emit(this.axelar, 'ContractCallExecuted').withArgs(commandId)
+        .to.emit(this.receiver, 'MessageReceived').withArgs(commandId, this.CAIP2, getAddress(this.sender), payload, attributes);
+    });
+  });
+});