add executor

Author: evan-gray

src/interfaces/executor/IExecutor.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/interfaces/IExecutor.sol
+interface IExecutor {
+    struct SignedQuoteHeader {
+        bytes4 prefix;
+        address quoterAddress;
+        bytes32 payeeAddress;
+        uint16 srcChain;
+        uint16 dstChain;
+        uint64 expiryTime;
+    }
+
+    event RequestForExecution(
+        address indexed quoterAddress,
+        uint256 amtPaid,
+        uint16 dstChain,
+        bytes32 dstAddr,
+        address refundAddr,
+        bytes signedQuote,
+        bytes requestBytes,
+        bytes relayInstructions
+    );
+
+    function requestExecution(
+        uint16 dstChain,
+        bytes32 dstAddr,
+        address refundAddr,
+        bytes calldata signedQuote,
+        bytes calldata requestBytes,
+        bytes calldata relayInstructions
+    ) external payable;
+}

src/interfaces/executor/IVaaV1Receiver.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/interfaces/IVaaV1Receiver.sol
+/// @notice Any contract that wishes to receive V1 VAAs from the executor needs to implement `IVaaV1Receiver`.
+interface IVaaV1Receiver {
+    /// @notice Receive an attested message from the executor relayer.
+    /// @param msg The attested message payload.
+    function executeVAAv1(bytes memory msg) external payable;
+}

src/libraries/ConsistencyConfigMaker.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {BytesParsing} from "wormhole-sdk/libraries/BytesParsing.sol";
+
+// from https://github.com/wormhole-foundation/wormhole/blob/39081fa2936badf178f8b7e5eb63074d3308bf7d/ethereum/contracts/custom_consistency_level/libraries/ConfigMakers.sol
+library ConsistencyConfigMaker {
+    uint8 public constant TYPE_ADDITIONAL_BLOCKS = 1;
+
+    //blocksToWait specifies the number of additional blocks to wait after the consistency level is reached.
+    function makeAdditionalBlocksConfig(uint8 consistencyLevel, uint16 blocksToWait)
+        internal
+        pure
+        returns (bytes32 ret)
+    {
+        bytes28 padding;
+        (ret,) = BytesParsing.asBytes32MemUnchecked(
+            abi.encodePacked(TYPE_ADDITIONAL_BLOCKS, consistencyLevel, blocksToWait, padding), 0
+        );
+    }
+}

src/libraries/ConsistencyConfigMakers.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/libraries/ExecutorMessages.sol
+library ExecutorMessages {
+    bytes4 private constant REQ_VAA_V1 = "ERV1";
+    bytes4 private constant REQ_NTT_V1 = "ERN1";
+    bytes4 private constant REQ_CCTP_V1 = "ERC1";
+    bytes4 private constant REQ_CCTP_V2 = "ERC2";
+
+    /// @notice Payload length will not fit in a uint32.
+    /// @dev Selector: 492f620d.
+    error PayloadTooLarge();
+
+    /// @notice Encodes a version 1 VAA request payload.
+    /// @param emitterChain The emitter chain from the VAA.
+    /// @param emitterAddress The emitter address from the VAA.
+    /// @param sequence The sequence number from the VAA.
+    /// @return bytes The encoded request.
+    function makeVAAv1Request(uint16 emitterChain, bytes32 emitterAddress, uint64 sequence)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodePacked(REQ_VAA_V1, emitterChain, emitterAddress, sequence);
+    }
+
+    /// @notice Encodes a version 1 NTT request payload.
+    /// @param srcChain The source chain for the NTT transfer.
+    /// @param srcManager The source manager for the NTT transfer.
+    /// @param messageId The manager message id for the NTT transfer.
+    /// @return bytes The encoded request.
+    function makeNTTv1Request(uint16 srcChain, bytes32 srcManager, bytes32 messageId)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodePacked(REQ_NTT_V1, srcChain, srcManager, messageId);
+    }
+
+    /// @notice Encodes a version 1 CCTP request payload.
+    /// @param sourceDomain The source chain for the CCTP transfer.
+    /// @param nonce The nonce of the CCTP transfer.
+    /// @return bytes The encoded request.
+    function makeCCTPv1Request(uint32 sourceDomain, uint64 nonce) internal pure returns (bytes memory) {
+        return abi.encodePacked(REQ_CCTP_V1, sourceDomain, nonce);
+    }
+
+    /// @notice Encodes a version 2 CCTP request payload.
+    ///         This request currently assumes the Executor will auto detect the event off chain.
+    ///         That may change in the future, in which case this interface would change.
+    /// @return bytes The encoded request.
+    function makeCCTPv2Request() internal pure returns (bytes memory) {
+        return abi.encodePacked(REQ_CCTP_V2, uint8(1));
+    }
+}

src/libraries/executor/ExecutorMessages.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/src/libraries/RelayInstructions.sol
+library RelayInstructions {
+    uint8 private constant RECV_INST_TYPE_GAS = uint8(1);
+    uint8 private constant RECV_INST_TYPE_DROP_OFF = uint8(2);
+
+    /// @notice Encodes the gas parameters for the relayer.
+    /// @dev This instruction may be specified more than once. If so, the relayer should sum the values.
+    /// @param gasLimit The gas limit passed to the relayer.
+    /// @param msgVal The additional message value passed to the relayer. This may be zero.
+    /// @return bytes The encoded instruction bytes.
+    function encodeGas(uint128 gasLimit, uint128 msgVal) internal pure returns (bytes memory) {
+        return abi.encodePacked(RECV_INST_TYPE_GAS, gasLimit, msgVal);
+    }
+
+    /// @notice Encodes the gas drop off parameters for the relayer.
+    /// @param dropOff The amount of gas to be dropped off.
+    /// @param recipient The recipient of the drop off.
+    /// @return bytes The encoded instruction bytes.
+    function encodeGasDropOffInstructions(uint128 dropOff, bytes32 recipient) internal pure returns (bytes memory) {
+        return abi.encodePacked(RECV_INST_TYPE_DROP_OFF, dropOff, recipient);
+    }
+}

src/libraries/executor/RelayInstructions.sol

@@ -2,13 +2,14 @@
 pragma solidity ^0.8.0;
 
 import {Test, console} from "forge-std/Test.sol";
-import {ConsistencyConfigMakers} from "../src/libraries/ConsistencyConfigMakers.sol";
+import {CONSISTENCY_LEVEL_SAFE} from "../src/constants/ConsistencyLevel.sol";
+import {ConsistencyConfigMaker} from "../src/libraries/ConsistencyConfigMaker.sol";
 
 // from https://github.com/wormhole-foundation/wormhole/blob/39081fa2936badf178f8b7e5eb63074d3308bf7d/ethereum/forge-test/CustomConsistencyLevel.t.sol
 contract CustomConsistencyLevelTest is Test {
     function test_makeAdditionalBlocksConfig() public {
         bytes32 expected = 0x01c9002a00000000000000000000000000000000000000000000000000000000;
-        bytes32 result = ConsistencyConfigMakers.makeAdditionalBlocksConfig(201, 42);
+        bytes32 result = ConsistencyConfigMaker.makeAdditionalBlocksConfig(CONSISTENCY_LEVEL_SAFE, 42);
         assertEq(expected, result);
     }
 }

test/CustomConsistencyLevel.t.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Test, console} from "forge-std/Test.sol";
+import {ExecutorMessages} from "../../src/libraries/executor/ExecutorMessages.sol";
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/test/ExecutorMessages.t.sol
+contract ExecutorMessagesTest is Test {
+    function test_makeVAAv1Request() public {
+        uint16 emitterChain = 7;
+        bytes32 emitterAddress = bytes32(uint256(uint160(0xdeadbeef)));
+        bytes memory expected = abi.encodePacked("ERV1", emitterChain, emitterAddress, uint64(42));
+        bytes memory buf = ExecutorMessages.makeVAAv1Request(emitterChain, emitterAddress, 42);
+        assertEq(expected, buf);
+    }
+
+    function test_makeNTTv1Request() public {
+        uint16 srcChain = 7;
+        bytes32 srcManager = bytes32(uint256(uint160(0xdeadbeef)));
+        bytes32 messageId = bytes32(uint256(42));
+        bytes memory expected = abi.encodePacked("ERN1", srcChain, srcManager, messageId);
+        bytes memory buf = ExecutorMessages.makeNTTv1Request(srcChain, srcManager, messageId);
+        assertEq(expected, buf);
+    }
+
+    function test_makeCCTPv1Request() public {
+        uint32 srcDomain = 7;
+        uint64 nonce = 42;
+        bytes memory expected = abi.encodePacked("ERC1", srcDomain, nonce);
+        bytes memory buf = ExecutorMessages.makeCCTPv1Request(srcDomain, nonce);
+        assertEq(expected, buf);
+    }
+
+    function test_makeCCTPv2Request() public {
+        bytes memory expected = abi.encodePacked("ERC2", uint8(1));
+        bytes memory buf = ExecutorMessages.makeCCTPv2Request();
+        assertEq(expected, buf);
+    }
+}

test/executor/ExecutorMessages.t.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Test, console} from "forge-std/Test.sol";
+import {RelayInstructions} from "../../src/libraries/executor/RelayInstructions.sol";
+
+// from https://github.com/wormholelabs-xyz/example-messaging-executor/blob/ec5daea3c03f8860a62c23e28db5c6dc8771a9ce/evm/test/RelayInstructions.t.sol
+contract RelayInstructionsTest is Test {
+    function test_encodeGas() public {
+        uint128 gasLimit = 123456000;
+        uint128 msgVal = 42000;
+        bytes memory expected = abi.encodePacked(uint8(1), gasLimit, msgVal);
+        bytes memory buf = RelayInstructions.encodeGas(gasLimit, msgVal);
+        assertEq(expected, buf);
+    }
+
+    function test_encodeGasDropOffInstructions() public {
+        uint128 dropOff = 123456000;
+        bytes32 recipient = bytes32(uint256(uint160(0xdeadbeef)));
+        bytes memory expected = abi.encodePacked(uint8(2), dropOff, recipient);
+        bytes memory buf = RelayInstructions.encodeGasDropOffInstructions(dropOff, recipient);
+        assertEq(expected, buf);
+    }
+
+    function test_multipleInstructions() public {
+        uint128 gasLimit = 123456000;
+        uint128 msgVal = 42000;
+        uint128 dropOff = 123456000;
+        bytes32 recipient = bytes32(uint256(uint160(0xdeadbeef)));
+        bytes memory expected = abi.encodePacked(uint8(1), gasLimit, msgVal, uint8(2), dropOff, recipient);
+        bytes memory buf = abi.encodePacked(
+            RelayInstructions.encodeGas(gasLimit, msgVal),
+            RelayInstructions.encodeGasDropOffInstructions(dropOff, recipient)
+        );
+        assertEq(expected, buf);
+    }
+}