@layerzerolabs/protocol-v2-messagelib-evm-contracts 1.2.95

package/contracts/uln/interfaces/IDVNFeeLib.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IDVN } from "./IDVN.sol";
+
+interface IDVNFeeLib {
+    struct FeeParams {
+        address priceFeed;
+        uint32 dstEid;
+        uint64 confirmations;
+        address sender;
+        uint64 quorum;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct FeeParamsForRead {
+        address priceFeed;
+        address sender;
+        uint64 quorum;
+        uint16 defaultMultiplierBps;
+    }
+
+    error DVN_UnsupportedOptionType(uint8 optionType);
+    error DVN_EidNotSupported(uint32 eid);
+    error DVN_TimestampOutOfRange(uint32 eid, uint64 timestamp);
+    error DVN_INVALID_INPUT_LENGTH();
+
+    function getFeeOnSend(
+        FeeParams calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external payable returns (uint256 fee);
+
+    function getFee(
+        FeeParams calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+
+    function getFeeOnSend(
+        FeeParamsForRead calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external payable returns (uint256 fee);
+
+    function getFee(
+        FeeParamsForRead calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+
+    function version() external view returns (uint64 major, uint8 minor);
+}

package/contracts/uln/interfaces/ILayerZeroDVN.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroDVN {
+    struct AssignJobParam {
+        uint32 dstEid;
+        bytes packetHeader;
+        bytes32 payloadHash;
+        uint64 confirmations;
+        address sender;
+    }
+
+    // @notice query price and assign jobs at the same time
+    // @param _dstEid - the destination endpoint identifier
+    // @param _packetHeader - version + nonce + path
+    // @param _payloadHash - hash of guid + message
+    // @param _confirmations - block confirmation delay before relaying blocks
+    // @param _sender - the source sending contract address
+    // @param _options - options
+    function assignJob(AssignJobParam calldata _param, bytes calldata _options) external payable returns (uint256 fee);
+
+    // @notice query the dvn fee for relaying block information to the destination chain
+    // @param _dstEid the destination endpoint identifier
+    // @param _confirmations - block confirmation delay before relaying blocks
+    // @param _sender - the source sending contract address
+    // @param _options - options
+    function getFee(
+        uint32 _dstEid,
+        uint64 _confirmations,
+        address _sender,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+}

package/contracts/uln/interfaces/ILayerZeroReadDVN.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroReadDVN {
+    // @notice query price and assign jobs at the same time
+    // @param _packetHeader - version + nonce + path
+    // @param _cmd - the command to be executed to obtain the payload
+    // @param _options - options
+    function assignJob(
+        address _sender,
+        bytes calldata _packetHeader,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external payable returns (uint256 fee);
+
+    // @notice query the dvn fee for relaying block information to the destination chain
+    // @param _packetHeader - version + nonce + path
+    // @param _cmd - the command to be executed to obtain the payload
+    // @param _options - options
+    function getFee(
+        address _sender,
+        bytes calldata _packetHeader,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+}

package/contracts/uln/interfaces/IReceiveUlnE2.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+/// @dev should be implemented by the ReceiveUln302 contract and future ReceiveUln contracts on EndpointV2
+interface IReceiveUlnE2 {
+    /// @notice for each dvn to verify the payload
+    /// @dev this function signature 0x0223536e
+    function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external;
+
+    /// @notice verify the payload at endpoint, will check if all DVNs verified
+    function commitVerification(bytes calldata _packetHeader, bytes32 _payloadHash) external;
+}

package/contracts/uln/interfaces/adapters/IAxelarDVNAdapter.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IAxelarDVNAdapter {
+    struct MultiplierParam {
+        uint32 dstEid;
+        uint16 multiplierBps;
+    }
+
+    struct FloorMarginUSDParam {
+        uint32 dstEid;
+        uint128 floorMarginUSD;
+    }
+
+    struct NativeGasFeeParam {
+        uint32 dstEid;
+        uint256 nativeGasFee;
+    }
+
+    struct DstConfigParam {
+        uint32 eid;
+        string chainName;
+        string peer;
+        uint16 multiplierBps;
+        uint256 nativeGasFee;
+    }
+
+    struct DstConfig {
+        string chainName;
+        string peer;
+        uint16 multiplierBps;
+        uint256 nativeGasFee;
+    }
+
+    struct SrcConfig {
+        uint32 eid;
+        string peer;
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event NativeGasFeeSet(NativeGasFeeParam[] params);
+    event MultiplierSet(MultiplierParam[] params);
+    event FloorMarginUSDSet(FloorMarginUSDParam[] params);
+
+    error AxelarDVNAdapter_UntrustedPeer(string chainName, string peer);
+    error AxelarDVNAdapter_OnlyWorkerFeeLib();
+
+    function withdrawToFeeLib(address _sendLib) external;
+}

package/contracts/uln/interfaces/adapters/IAxelarDVNAdapterFeeLib.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IAxelarDVNAdapter } from "./IAxelarDVNAdapter.sol";
+
+interface IAxelarDVNAdapterFeeLib {
+    struct Param {
+        uint32 dstEid;
+        uint64 confirmations;
+        address sender;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct DstConfig {
+        uint64 gas;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint64 gas;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event TokenWithdrawn(address token, address to, uint256 amount);
+    event GasServiceSet(address gasService);
+    event PriceFeedSet(address priceFeed);
+    event NativeGasFeeMultiplierBpsSet(uint16 multiplierBps);
+
+    error AxelarDVNAdapter_OptionsUnsupported();
+    error AxelarDVNAdapter_InsufficientBalance(uint256 actual, uint256 requested);
+    error AxelarDVNAdapter_EidNotSupported(uint32 eid);
+
+    function getFeeOnSend(
+        Param calldata _params,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes memory _payload,
+        bytes calldata _options,
+        address _sendLib
+    ) external payable returns (uint256 totalFee);
+
+    function getFee(
+        Param calldata _params,
+        IAxelarDVNAdapter.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 totalFee);
+}

package/contracts/uln/interfaces/adapters/ICCIPDVNAdapter.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ICCIPDVNAdapter {
+    struct DstConfigParam {
+        uint32 eid;
+        uint16 multiplierBps;
+        uint64 chainSelector;
+        uint256 gas;
+        bytes peer;
+    }
+
+    struct DstConfig {
+        // https://docs.chain.link/ccip/supported-networks/v1_2_0/testnet#ethereum-sepolia
+        // https://docs.chain.link/ccip/supported-networks/v1_0_0/mainnet
+        uint64 chainSelector;
+        uint16 multiplierBps;
+        // https://github.com/smartcontractkit/ccip/blob/ccip-develop/contracts/src/v0.8/ccip/libraries/Client.sol#L22C51-L22C51
+        // for destination is evm chain, need to use `abi.encode(address)` to get the peer
+        bytes peer;
+        uint256 gas;
+    }
+
+    struct SrcConfig {
+        uint32 eid;
+        bytes peer;
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+
+    error CCIPDVNAdapter_UntrustedPeer(uint64 chainSelector, bytes peer);
+    error CCIPDVNAdapter_InvalidRouter(address router);
+}

package/contracts/uln/interfaces/adapters/ICCIPDVNAdapterFeeLib.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { Client } from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
+import { IRouterClient } from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+import { ICCIPDVNAdapter } from "./ICCIPDVNAdapter.sol";
+
+interface ICCIPDVNAdapterFeeLib {
+    struct Param {
+        uint32 dstEid;
+        uint64 confirmations;
+        address sender;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct DstConfig {
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+
+    error CCIPDVNAdapter_OptionsUnsupported();
+    error CCIPDVNAdapter_EidNotSupported(uint32 eid);
+
+    function getFeeOnSend(
+        Param calldata _params,
+        ICCIPDVNAdapter.DstConfig calldata _dstConfig,
+        Client.EVM2AnyMessage calldata _message,
+        bytes calldata _options,
+        IRouterClient _router
+    ) external payable returns (uint256 ccipFee, uint256 totalFee);
+
+    function getFee(
+        Param calldata _params,
+        ICCIPDVNAdapter.DstConfig calldata _dstConfig,
+        Client.EVM2AnyMessage calldata _message,
+        bytes calldata _options,
+        IRouterClient _router
+    ) external view returns (uint256 totalFee);
+}

package/contracts/uln/libs/DVNOptions.sol

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";
+
+import { BitMap256 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/BitMaps.sol";
+import { CalldataBytesLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/CalldataBytesLib.sol";
+
+library DVNOptions {
+    using CalldataBytesLib for bytes;
+    using BytesLib for bytes;
+
+    uint8 internal constant WORKER_ID = 2;
+    uint8 internal constant OPTION_TYPE_PRECRIME = 1;
+
+    error DVN_InvalidDVNIdx();
+    error DVN_InvalidDVNOptions(uint256 cursor);
+
+    /// @dev group dvn options by its idx
+    /// @param _options [dvn_id][dvn_option][dvn_id][dvn_option]...
+    ///        dvn_option = [option_size][dvn_idx][option_type][option]
+    ///        option_size = len(dvn_idx) + len(option_type) + len(option)
+    ///        dvn_id: uint8, dvn_idx: uint8, option_size: uint16, option_type: uint8, option: bytes
+    /// @return dvnOptions the grouped options, still share the same format of _options
+    /// @return dvnIndices the dvn indices
+    function groupDVNOptionsByIdx(
+        bytes memory _options
+    ) internal pure returns (bytes[] memory dvnOptions, uint8[] memory dvnIndices) {
+        if (_options.length == 0) return (dvnOptions, dvnIndices);
+
+        uint8 numDVNs = getNumDVNs(_options);
+
+        // if there is only 1 dvn, we can just return the whole options
+        if (numDVNs == 1) {
+            dvnOptions = new bytes[](1);
+            dvnOptions[0] = _options;
+
+            dvnIndices = new uint8[](1);
+            dvnIndices[0] = _options.toUint8(3); // dvn idx
+            return (dvnOptions, dvnIndices);
+        }
+
+        // otherwise, we need to group the options by dvn_idx
+        dvnIndices = new uint8[](numDVNs);
+        dvnOptions = new bytes[](numDVNs);
+        unchecked {
+            uint256 cursor = 0;
+            uint256 start = 0;
+            uint8 lastDVNIdx = 255; // 255 is an invalid dvn_idx
+
+            while (cursor < _options.length) {
+                ++cursor; // skip worker_id
+
+                // optionLength asserted in getNumDVNs (skip check)
+                uint16 optionLength = _options.toUint16(cursor);
+                cursor += 2;
+
+                // dvnIdx asserted in getNumDVNs (skip check)
+                uint8 dvnIdx = _options.toUint8(cursor);
+
+                // dvnIdx must equal to the lastDVNIdx for the first option
+                // so it is always skipped in the first option
+                // this operation slices out options whenever the scan finds a different lastDVNIdx
+                if (lastDVNIdx == 255) {
+                    lastDVNIdx = dvnIdx;
+                } else if (dvnIdx != lastDVNIdx) {
+                    uint256 len = cursor - start - 3; // 3 is for worker_id and option_length
+                    bytes memory opt = _options.slice(start, len);
+                    _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, opt);
+
+                    // reset the start and lastDVNIdx
+                    start += len;
+                    lastDVNIdx = dvnIdx;
+                }
+
+                cursor += optionLength;
+            }
+
+            // skip check the cursor here because the cursor is asserted in getNumDVNs
+            // if we have reached the end of the options, we need to process the last dvn
+            uint256 size = cursor - start;
+            bytes memory op = _options.slice(start, size);
+            _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, op);
+
+            // revert dvnIndices to start from 0
+            for (uint8 i = 0; i < numDVNs; ++i) {
+                --dvnIndices[i];
+            }
+        }
+    }
+
+    function _insertDVNOptions(
+        bytes[] memory _dvnOptions,
+        uint8[] memory _dvnIndices,
+        uint8 _dvnIdx,
+        bytes memory _newOptions
+    ) internal pure {
+        // dvnIdx starts from 0 but default value of dvnIndices is 0,
+        // so we tell if the slot is empty by adding 1 to dvnIdx
+        if (_dvnIdx == 255) revert DVN_InvalidDVNIdx();
+        uint8 dvnIdxAdj = _dvnIdx + 1;
+
+        for (uint256 j = 0; j < _dvnIndices.length; ++j) {
+            uint8 index = _dvnIndices[j];
+            if (dvnIdxAdj == index) {
+                _dvnOptions[j] = abi.encodePacked(_dvnOptions[j], _newOptions);
+                break;
+            } else if (index == 0) {
+                // empty slot, that means it is the first time we see this dvn
+                _dvnIndices[j] = dvnIdxAdj;
+                _dvnOptions[j] = _newOptions;
+                break;
+            }
+        }
+    }
+
+    /// @dev get the number of unique dvns
+    /// @param _options the format is the same as groupDVNOptionsByIdx
+    function getNumDVNs(bytes memory _options) internal pure returns (uint8 numDVNs) {
+        uint256 cursor = 0;
+        BitMap256 bitmap;
+
+        // find number of unique dvn_idx
+        unchecked {
+            while (cursor < _options.length) {
+                ++cursor; // skip worker_id
+
+                uint16 optionLength = _options.toUint16(cursor);
+                cursor += 2;
+                if (optionLength < 2) revert DVN_InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type
+
+                uint8 dvnIdx = _options.toUint8(cursor);
+
+                // if dvnIdx is not set, increment numDVNs
+                // max num of dvns is 255, 255 is an invalid dvn_idx
+                // The order of the dvnIdx is not required to be sequential, as enforcing the order may weaken
+                // the composability of the options. e.g. if we refrain from enforcing the order, an OApp that has
+                // already enforced certain options can append additional options to the end of the enforced
+                // ones without restrictions.
+                if (dvnIdx == 255) revert DVN_InvalidDVNIdx();
+                if (!bitmap.get(dvnIdx)) {
+                    ++numDVNs;
+                    bitmap = bitmap.set(dvnIdx);
+                }
+
+                cursor += optionLength;
+            }
+        }
+        if (cursor != _options.length) revert DVN_InvalidDVNOptions(cursor);
+    }
+
+    /// @dev decode the next dvn option from _options starting from the specified cursor
+    /// @param _options the format is the same as groupDVNOptionsByIdx
+    /// @param _cursor the cursor to start decoding
+    /// @return optionType the type of the option
+    /// @return option the option
+    /// @return cursor the cursor to start decoding the next option
+    function nextDVNOption(
+        bytes calldata _options,
+        uint256 _cursor
+    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
+        unchecked {
+            // skip worker id
+            cursor = _cursor + 1;
+
+            // read option size
+            uint16 size = _options.toU16(cursor);
+            cursor += 2;
+
+            // read option type
+            optionType = _options.toU8(cursor + 1); // skip dvn_idx
+
+            // startCursor and endCursor are used to slice the option from _options
+            uint256 startCursor = cursor + 2; // skip option type and dvn_idx
+            uint256 endCursor = cursor + size;
+            option = _options[startCursor:endCursor];
+            cursor += size;
+        }
+    }
+}

package/contracts/uln/libs/ReadCmdCodecV1.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { SupportedCmdTypes, SupportedCmdTypesLib } from "./SupportedCmdTypes.sol";
+
+library ReadCmdCodecV1 {
+    uint16 internal constant CMD_VERSION = 1;
+    uint8 internal constant REQUEST_VERSION = 1;
+    uint16 internal constant RESOLVER_TYPE_SINGLE_VIEW_EVM_CALL = 1;
+    uint8 internal constant COMPUTE_VERSION = 1;
+    uint16 internal constant COMPUTE_TYPE_SINGLE_VIEW_EVM_CALL = 1;
+
+    uint8 internal constant COMPUTE_SETTING_MAP_ONLY = 0;
+    uint8 internal constant COMPUTE_SETTING_REDUCE_ONLY = 1;
+    uint8 internal constant COMPUTE_SETTING_MAP_AND_REDUCE = 2;
+
+    error InvalidCmd();
+    error InvalidVersion();
+    error InvalidType();
+
+    struct Cmd {
+        uint16 numEvmCallRequestV1;
+        bool evmCallComputeV1Map;
+        bool evmCallComputeV1Reduce;
+    }
+
+    function decode(
+        bytes calldata _cmd,
+        function(uint32, bool, uint64, uint8) view _assertCmdTypeSupported
+    ) internal view returns (Cmd memory cmd) {
+        uint256 cursor = 0;
+        // decode the header in scope, depress stack too deep
+        {
+            uint16 cmdVersion = uint16(bytes2(_cmd[cursor:cursor + 2]));
+            cursor += 2;
+            if (cmdVersion != CMD_VERSION) revert InvalidVersion();
+
+            cursor += 2; // skip appCmdLabel
+
+            uint16 requestCount = uint16(bytes2(_cmd[cursor:cursor + 2]));
+            cursor += 2;
+
+            // there is only one request type in this version, so total request count should be the same as numEvmCallRequestV1
+            if (requestCount == 0) revert InvalidCmd();
+            cmd.numEvmCallRequestV1 = requestCount;
+        }
+
+        // decode the requests
+        for (uint16 i = 0; i < cmd.numEvmCallRequestV1; i++) {
+            uint8 requestVersion = uint8(_cmd[cursor]);
+            cursor += 1;
+            if (requestVersion != REQUEST_VERSION) revert InvalidVersion();
+
+            // skip appRequestLabel
+            cursor += 2;
+
+            uint16 resolverType = uint16(bytes2(_cmd[cursor:cursor + 2]));
+            cursor += 2;
+
+            if (resolverType == RESOLVER_TYPE_SINGLE_VIEW_EVM_CALL) {
+                uint16 requestSize = uint16(bytes2(_cmd[cursor:cursor + 2]));
+                cursor += 2;
+
+                // decode the request in scope, depress stack too deep
+                {
+                    uint256 requestCursor = cursor;
+                    uint32 targetEid = uint32(bytes4(_cmd[requestCursor:requestCursor + 4]));
+                    requestCursor += 4;
+
+                    bool isBlockNum = uint8(_cmd[requestCursor]) == 1;
+                    requestCursor += 1;
+
+                    uint64 blockNumOrTimestamp = uint64(bytes8(_cmd[requestCursor:requestCursor + 8]));
+
+                    _assertCmdTypeSupported(
+                        targetEid,
+                        isBlockNum,
+                        blockNumOrTimestamp,
+                        SupportedCmdTypesLib.CMD_V1__REQUEST_V1__EVM_CALL
+                    );
+                }
+
+                if (cursor + requestSize > _cmd.length) revert InvalidCmd();
+                cursor += requestSize;
+            } else {
+                revert InvalidType();
+            }
+        }
+
+        // decode the compute if it exists
+        if (cursor < _cmd.length) {
+            uint8 computeVersion = uint8(_cmd[cursor]);
+            cursor += 1;
+            if (computeVersion != COMPUTE_VERSION) revert InvalidVersion();
+
+            uint16 computeType = uint16(bytes2(_cmd[cursor:cursor + 2]));
+            cursor += 2;
+            if (computeType != COMPUTE_TYPE_SINGLE_VIEW_EVM_CALL) revert InvalidType();
+
+            uint8 computeSetting = uint8(_cmd[cursor]);
+            cursor += 1;
+
+            if (computeSetting == COMPUTE_SETTING_MAP_ONLY) {
+                cmd.evmCallComputeV1Map = true;
+            } else if (computeSetting == COMPUTE_SETTING_REDUCE_ONLY) {
+                cmd.evmCallComputeV1Reduce = true;
+            } else if (computeSetting == COMPUTE_SETTING_MAP_AND_REDUCE) {
+                cmd.evmCallComputeV1Map = true;
+                cmd.evmCallComputeV1Reduce = true;
+            } else {
+                revert InvalidType();
+            }
+
+            uint32 targetEid = uint32(bytes4(_cmd[cursor:cursor + 4]));
+            cursor += 4;
+
+            bool isBlockNum = uint8(_cmd[cursor]) == 1;
+            cursor += 1;
+
+            uint64 blockNumOrTimestamp = uint64(bytes8(_cmd[cursor:cursor + 8]));
+            cursor += 8;
+
+            _assertCmdTypeSupported(
+                targetEid,
+                isBlockNum,
+                blockNumOrTimestamp,
+                SupportedCmdTypesLib.CMD_V1__COMPUTE_V1__EVM_CALL
+            );
+
+            // assert the remaining length: confirmations(2), to(20)
+            cursor += 22;
+        }
+        if (cursor != _cmd.length) revert InvalidCmd();
+    }
+}

package/contracts/uln/libs/SupportedCmdTypes.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { BitMap256 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/BitMaps.sol";
+
+struct SupportedCmdTypes {
+    mapping(uint32 => BitMap256) cmdTypes; // support options
+}
+
+using SupportedCmdTypesLib for SupportedCmdTypes global;
+
+library SupportedCmdTypesLib {
+    // the max number of supported command types is 256
+    uint8 internal constant CMD_V1__REQUEST_V1__EVM_CALL = 0;
+    uint8 internal constant CMD_V1__COMPUTE_V1__EVM_CALL = 1;
+    uint8 internal constant CMD_V1__TIMESTAMP_VALIDATE = 2; // validate timestamp, to check if the timestamp is out of range
+    // more types can be added here in the future
+
+    error UnsupportedTargetEid();
+
+    function assertSupported(SupportedCmdTypes storage _self, uint32 _targetEid, uint8 _type) internal view {
+        if (!isSupported(_self, _targetEid, _type)) revert UnsupportedTargetEid();
+    }
+
+    function isSupported(SupportedCmdTypes storage _self, uint32 _targetEid, uint8 _type) internal view returns (bool) {
+        return _self.cmdTypes[_targetEid].get(_type);
+    }
+}