feat: complete bridge adapter invariants

test/invariant-tests/AccessControl.Invariant.sol

@@ -8,7 +8,7 @@ import {Vm, Test} from "forge-std/Test.sol";
 import "test/Setup.t.sol";
 
 /// handler import
-import {AccessControlSenderHandler} from "test/invariant-tests/handlers/AccessControlSender.handler.sol";
+import {AccessControlSenderHandler} from "test/invariant-tests/handlers/AccessControlSender.Handler.sol";
 
 contract AccessControlHandlerInvariant is Setup {
  AccessControlSenderHandler public handler;

test/invariant-tests/BridgeAdapter.Invariant.sol

@@ -0,0 +1,60 @@
+pragma solidity >=0.8.9;
+
+/// library imports
+import {Vm, Test} from "forge-std/Test.sol";
+
+/// local imports
+import "test/Setup.t.sol";
+
+/// handler import
+import {BridgeAdapterHandler} from "test/invariant-tests/handlers/BridgeAdapter.Handler.sol";
+
+/// @notice invariants for bridge adapters receiving messages
+contract BridgeAdapterInvariant is Setup {
+ BridgeAdapterHandler public handler;
+
+ /// @notice initializes the setup
+ function setUp() public override {
+ /// @dev calls setup to spin up test contracts
+ super.setUp();
+
+ /// @dev selects fork and deploy the handlers
+ vm.selectFork(fork[BSC_CHAIN_ID]);
+ handler = new BridgeAdapterHandler(
+ contractAddress[BSC_CHAIN_ID]["WORMHOLE_RECEIVER_ADAPTER"],
+ contractAddress[BSC_CHAIN_ID]["AXELAR_RECEIVER_ADAPTER"],
+ contractAddress[BSC_CHAIN_ID]["MMA_RECEIVER"]
+ );
+
+ /// @dev bind the handler as target for invariant
+ targetContract(address(handler));
+ }
+
+ function invariant_test_bridge_adapter_receivers() public {
+ if (handler.success() && handler.lastBridge() == 1) {
+ assertTrue(
+ WormholeReceiverAdapter(contractAddress[BSC_CHAIN_ID]["WORMHOLE_RECEIVER_ADAPTER"]).isMessageExecuted(
+ handler.lastMessageId()
+ )
+ );
+ assertTrue(
+ WormholeReceiverAdapter(contractAddress[BSC_CHAIN_ID]["WORMHOLE_RECEIVER_ADAPTER"]).deliveryHashStatus(
+ handler.lastMessageHash()
+ )
+ );
+ }
+
+ if (handler.success() && handler.lastBridge() == 2) {
+ assertTrue(
+ AxelarReceiverAdapter(contractAddress[BSC_CHAIN_ID]["AXELAR_RECEIVER_ADAPTER"]).isMessageExecuted(
+ handler.lastMessageId()
+ )
+ );
+ assertTrue(
+ AxelarReceiverAdapter(contractAddress[BSC_CHAIN_ID]["AXELAR_RECEIVER_ADAPTER"]).commandIdStatus(
+ handler.lastMessageHash()
+ )
+ );
+ }
+ }
+}

test/invariant-tests/handlers/AdapterList.Handler.sol

@@ -8,7 +8,7 @@ import "forge-std/Test.sol";
 import {MessageSenderGAC} from "src/controllers/MessageSenderGAC.sol";
 import {MultiBridgeMessageSender} from "src/MultiBridgeMessageSender.sol";
 
-/// @notice handler for testing maintaining adapter list
+/// @notice handler for invariant testing maintaining adapter list
 contract AdapterListHandler is Test {
  /// @notice local state
  MultiBridgeMessageSender public multiBridgeMessageSender;

test/invariant-tests/handlers/BridgeAdapter.Handler.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity >=0.8.9;
+
+/// library imports
+import "forge-std/Test.sol";
+
+/// local imports
+import {WormholeReceiverAdapter} from "src/adapters/wormhole/WormholeReceiverAdapter.sol";
+import {AxelarReceiverAdapter} from "src/adapters/axelar/AxelarReceiverAdapter.sol";
+import {AdapterPayload} from "src/libraries/Types.sol";
+import "src/libraries/TypeCasts.sol";
+import "src/libraries/Message.sol";
+import "src/adapters/axelar/libraries/StringAddressConversion.sol";
+
+/// @notice helper interface of axelar gateway to simulaate approve contract call
+interface IAxelarGateway {
+ function approveContractCall(bytes calldata params, bytes32 commandId) external;
+
+ function callContract(string calldata destinationChain, string calldata contractAddress, bytes calldata payload)
+ external;
+}
+
+/// @notice handler for invariant testing receiver bridge adapters
+contract BridgeAdapterHandler is Test {
+ /// @notice local state
+ WormholeReceiverAdapter public wormhole;
+ AxelarReceiverAdapter public axelar;
+
+ address public multiBridgeReceiver;
+ bytes32 public lastMessageId;
+ bytes32 public lastMessageHash;
+
+ uint256 public lastBridge;
+
+ bool public success;
+
+ /// @notice modifier to prank caller
+ modifier prank(address _prankster) {
+ vm.startPrank(_prankster);
+ _;
+ vm.stopPrank();
+ }
+
+ /// @notice initial setup contracts
+ constructor(address _wormhole, address _axelar, address _multiBridgeReceiver) {
+ wormhole = WormholeReceiverAdapter(_wormhole);
+ axelar = AxelarReceiverAdapter(_axelar);
+ multiBridgeReceiver = _multiBridgeReceiver;
+ }
+
+ /// @notice helper for wormhole receivers
+ function receiveWormholeMessages(
+ AdapterPayload memory _payload,
+ MessageLibrary.Message memory _data,
+ bytes[] memory _vaas,
+ bytes32 _deliveryHash
+ ) external prank(wormhole.relayer()) {
+ success = false;
+ vm.assume(_payload.msgId != bytes32(0));
+
+ lastBridge = 1;
+ _payload.receiverAdapter = address(wormhole);
+ _payload.finalDestination = multiBridgeReceiver;
+ _data.dstChainId = 56;
+ _data.srcChainId = 1;
+ _payload.data = abi.encode(_data);
+
+ lastMessageId = _payload.msgId;
+ lastMessageHash = _deliveryHash;
+ success = true;
+
+ wormhole.receiveWormholeMessages(
+ abi.encode(_payload),
+ _vaas,
+ TypeCasts.addressToBytes32(wormhole.senderAdapter()),
+ wormhole.senderChainId(),
+ _deliveryHash
+ );
+ }
+
+ /// @notice helper for axelar receivers
+ function receiveAxelarMessages(
+ AdapterPayload memory _payload,
+ MessageLibrary.Message memory _data,
+ bytes32 _commandId
+ ) external prank(address(axelar.gateway())) {
+ lastBridge = 2;
+ _payload.receiverAdapter = address(axelar);
+ _payload.finalDestination = multiBridgeReceiver;
+
+ _data.dstChainId = 56;
+ _data.srcChainId = 1;
+ _payload.data = abi.encode(_data);
+
+ /// @notice simulating the payload existence on axelar's gateway
+ /// @dev helps us bypass NOT_APPROVED_BY_GATEWAY error on axelar adapter
+ IAxelarGateway(address(axelar.gateway())).approveContractCall(
+ abi.encode(
+ "ethereum",
+ StringAddressConversion.toString(address(axelar.senderAdapter())),
+ address(axelar),
+ keccak256(abi.encode(_payload)),
+ bytes32(0),
+ 0
+ ),
+ _commandId
+ );
+
+ lastMessageId = _payload.msgId;
+ lastMessageHash = _commandId;
+ success = true;
+
+ axelar.execute(
+ _commandId,
+ axelar.senderChainId(),
+ StringAddressConversion.toString(axelar.senderAdapter()),
+ abi.encode(_payload)
+ );
+ }
+}