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

package/contracts/uln/readlib/ReadLib1002View.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { EndpointV2ViewUpgradeable } from "@layerzerolabs/lz-evm-protocol-v2/contracts/EndpointV2ViewUpgradeable.sol";
+
+import { ReadLibConfig } from "./ReadLibBase.sol";
+import { ReadLib1002 } from "./ReadLib1002.sol";
+
+enum VerificationState {
+    Verifying,
+    Verifiable,
+    Verified,
+    NotInitializable,
+    Reorged
+}
+
+contract ReadLib1002View is EndpointV2ViewUpgradeable, Proxied {
+    using PacketV1Codec for bytes;
+
+    ReadLib1002 public readLib;
+    uint32 internal localEid;
+
+    function initialize(address _endpoint, address payable _readLib) external proxied initializer {
+        __EndpointV2View_init(_endpoint);
+        readLib = ReadLib1002(_readLib);
+        localEid = endpoint.eid();
+    }
+
+    /// @dev get a verifiable payload hash based on the payloadHashLookup from the DVNs
+    function getVerifiablePayloadHash(
+        address _receiver,
+        uint32 _srcEid,
+        bytes32 _headerHash,
+        bytes32 _cmdHash
+    ) public view returns (bytes32) {
+        ReadLibConfig memory config = readLib.getReadLibConfig(_receiver, _srcEid);
+        uint8 dvnsLength = config.requiredDVNCount + config.optionalDVNCount;
+        for (uint8 i = 0; i < dvnsLength; ++i) {
+            address dvn = i < config.requiredDVNCount
+                ? config.requiredDVNs[i]
+                : config.optionalDVNs[i - config.requiredDVNCount];
+
+            bytes32 payloadHash = readLib.hashLookup(_headerHash, _cmdHash, dvn);
+            if (readLib.verifiable(config, _headerHash, _cmdHash, payloadHash)) {
+                return payloadHash;
+            }
+        }
+        return EMPTY_PAYLOAD_HASH; // not found
+    }
+
+    /// @dev a verifiable requires it to be endpoint verifiable and committable
+    function verifiable(bytes calldata _packetHeader, bytes32 _cmdHash) external view returns (VerificationState) {
+        address receiver = _packetHeader.receiverB20();
+        uint32 srcEid = _packetHeader.srcEid();
+
+        Origin memory origin = Origin(srcEid, _packetHeader.sender(), _packetHeader.nonce());
+
+        // check endpoint initializable
+        if (!initializable(origin, receiver)) {
+            return VerificationState.NotInitializable;
+        }
+
+        // check endpoint verifiable. if false, that means it is executed and can not be verified
+        if (!endpoint.verifiable(origin, receiver)) {
+            return VerificationState.Verified;
+        }
+
+        // get the verifiable payload hash
+        bytes32 payloadHash = getVerifiablePayloadHash(receiver, srcEid, keccak256(_packetHeader), _cmdHash);
+
+        if (payloadHash == EMPTY_PAYLOAD_HASH) {
+            // if payload hash is not empty, it is verified
+            if (endpoint.inboundPayloadHash(receiver, srcEid, origin.sender, origin.nonce) != EMPTY_PAYLOAD_HASH) {
+                return VerificationState.Verified;
+            }
+
+            // otherwise, it is verifying
+            return VerificationState.Verifying;
+        }
+
+        // check if the cmdHash matches
+        if (readLib.cmdHashLookup(receiver, srcEid, origin.nonce) != _cmdHash) {
+            return VerificationState.Reorged;
+        }
+
+        // check if the payload hash matches
+        // endpoint allows re-verify, check if this payload has already been verified
+        if (endpoint.inboundPayloadHash(receiver, origin.srcEid, origin.sender, origin.nonce) == payloadHash) {
+            return VerificationState.Verified;
+        }
+
+        return VerificationState.Verifiable;
+    }
+}

package/contracts/uln/readlib/ReadLibBase.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+struct ReadLibConfig {
+    address executor;
+    // we store the length of required DVNs and optional DVNs instead of using DVN.length directly to save gas
+    uint8 requiredDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
+    uint8 optionalDVNCount; // 0 indicate DEFAULT, NIL_DVN_COUNT indicate NONE (to override the value of default)
+    uint8 optionalDVNThreshold; // (0, optionalDVNCount]
+    address[] requiredDVNs; // no duplicates. sorted an an ascending order. allowed overlap with optionalDVNs
+    address[] optionalDVNs; // no duplicates. sorted an an ascending order. allowed overlap with requiredDVNs
+}
+
+struct SetDefaultReadLibConfigParam {
+    uint32 eid;
+    ReadLibConfig config;
+}
+
+/// @dev includes the utility functions for checking ReadLib states and logics
+abstract contract ReadLibBase is Ownable {
+    address internal constant DEFAULT_CONFIG = address(0);
+    // reserved values for
+    uint8 internal constant DEFAULT = 0;
+    uint8 internal constant NIL_DVN_COUNT = type(uint8).max;
+    // 127 to prevent total number of DVNs (127 * 2) exceeding uint8.max (255)
+    // by limiting the total size, it would help constraint the design of DVNOptions
+    uint8 private constant MAX_COUNT = (type(uint8).max - 1) / 2;
+
+    mapping(address oapp => mapping(uint32 eid => ReadLibConfig config)) internal readLibConfigs;
+
+    error LZ_RL_Unsorted();
+    error LZ_RL_InvalidRequiredDVNCount();
+    error LZ_RL_InvalidOptionalDVNCount();
+    error LZ_RL_AtLeastOneDVN();
+    error LZ_RL_InvalidOptionalDVNThreshold();
+    error LZ_RL_UnsupportedEid(uint32 eid);
+    error LZ_RL_InvalidExecutor();
+
+    event DefaultReadLibConfigsSet(SetDefaultReadLibConfigParam[] params);
+    event ReadLibConfigSet(address oapp, uint32 eid, ReadLibConfig config);
+
+    // ============================ OnlyOwner ===================================
+
+    /// @dev about the DEFAULT ReadLib config
+    /// 1) its values are all LITERAL (e.g. 0 is 0). whereas in the oapp ReadLib config, 0 (default value) points to the default ReadLib config
+    ///     this design enables the oapp to point to DEFAULT config without explicitly setting the config
+    /// 2) its configuration is more restrictive than the oapp ReadLib config that
+    ///     a) it must not use NIL value, where NIL is used only by oapps to indicate the LITERAL 0
+    ///     b) it must have at least one DVN and executor
+    function setDefaultReadLibConfigs(SetDefaultReadLibConfigParam[] calldata _params) external onlyOwner {
+        for (uint256 i = 0; i < _params.length; ++i) {
+            SetDefaultReadLibConfigParam calldata param = _params[i];
+
+            // 2.a must not use NIL
+            if (param.config.requiredDVNCount == NIL_DVN_COUNT) revert LZ_RL_InvalidRequiredDVNCount();
+            if (param.config.optionalDVNCount == NIL_DVN_COUNT) revert LZ_RL_InvalidOptionalDVNCount();
+
+            // 2.b must have at least one dvn and executor
+            _assertAtLeastOneDVN(param.config);
+            if (param.config.executor == address(0x0)) revert LZ_RL_InvalidExecutor();
+
+            _setConfig(DEFAULT_CONFIG, param.eid, param.config);
+        }
+        emit DefaultReadLibConfigsSet(_params);
+    }
+
+    // ============================ View ===================================
+    // @dev assuming most oapps use default, we get default as memory and custom as storage to save gas
+    function getReadLibConfig(address _oapp, uint32 _remoteEid) public view returns (ReadLibConfig memory rtnConfig) {
+        ReadLibConfig storage defaultConfig = readLibConfigs[DEFAULT_CONFIG][_remoteEid];
+        ReadLibConfig storage customConfig = readLibConfigs[_oapp][_remoteEid];
+
+        address executor = customConfig.executor;
+        rtnConfig.executor = executor != address(0x0) ? executor : defaultConfig.executor;
+
+        if (customConfig.requiredDVNCount == DEFAULT) {
+            if (defaultConfig.requiredDVNCount > 0) {
+                // copy only if count > 0. save gas
+                rtnConfig.requiredDVNs = defaultConfig.requiredDVNs;
+                rtnConfig.requiredDVNCount = defaultConfig.requiredDVNCount;
+            } // else, do nothing
+        } else {
+            if (customConfig.requiredDVNCount != NIL_DVN_COUNT) {
+                rtnConfig.requiredDVNs = customConfig.requiredDVNs;
+                rtnConfig.requiredDVNCount = customConfig.requiredDVNCount;
+            } // else, do nothing
+        }
+
+        if (customConfig.optionalDVNCount == DEFAULT) {
+            if (defaultConfig.optionalDVNCount > 0) {
+                // copy only if count > 0. save gas
+                rtnConfig.optionalDVNs = defaultConfig.optionalDVNs;
+                rtnConfig.optionalDVNCount = defaultConfig.optionalDVNCount;
+                rtnConfig.optionalDVNThreshold = defaultConfig.optionalDVNThreshold;
+            }
+        } else {
+            if (customConfig.optionalDVNCount != NIL_DVN_COUNT) {
+                rtnConfig.optionalDVNs = customConfig.optionalDVNs;
+                rtnConfig.optionalDVNCount = customConfig.optionalDVNCount;
+                rtnConfig.optionalDVNThreshold = customConfig.optionalDVNThreshold;
+            }
+        }
+
+        // the final value must have at least one dvn
+        // it is possible that some default config result into 0 dvns
+        _assertAtLeastOneDVN(rtnConfig);
+    }
+
+    /// @dev Get the readLib config without the default config for the given remoteEid.
+    function getAppReadLibConfig(address _oapp, uint32 _remoteEid) external view returns (ReadLibConfig memory) {
+        return readLibConfigs[_oapp][_remoteEid];
+    }
+
+    // ============================ Internal ===================================
+    function _setReadLibConfig(uint32 _remoteEid, address _oapp, ReadLibConfig memory _param) internal {
+        _setConfig(_oapp, _remoteEid, _param);
+
+        // get ReadLib config again as a catch all to ensure the config is valid
+        getReadLibConfig(_oapp, _remoteEid);
+        emit ReadLibConfigSet(_oapp, _remoteEid, _param);
+    }
+
+    /// @dev a supported Eid must have a valid default readLib config, which has at least one dvn
+    function _isSupportedEid(uint32 _remoteEid) internal view returns (bool) {
+        ReadLibConfig storage defaultConfig = readLibConfigs[DEFAULT_CONFIG][_remoteEid];
+        return defaultConfig.requiredDVNCount > 0 || defaultConfig.optionalDVNThreshold > 0;
+    }
+
+    function _assertSupportedEid(uint32 _remoteEid) internal view {
+        if (!_isSupportedEid(_remoteEid)) revert LZ_RL_UnsupportedEid(_remoteEid);
+    }
+
+    // ============================ Private ===================================
+
+    function _assertAtLeastOneDVN(ReadLibConfig memory _config) private pure {
+        if (_config.requiredDVNCount == 0 && _config.optionalDVNThreshold == 0) revert LZ_RL_AtLeastOneDVN();
+    }
+
+    /// @dev this private function is used in both setDefaultReadLibConfigs and setReadLibConfig
+    function _setConfig(address _oapp, uint32 _eid, ReadLibConfig memory _param) private {
+        // @dev required dvns
+        // if dvnCount == NONE, dvns list must be empty
+        // if dvnCount == DEFAULT, dvn list must be empty
+        // otherwise, dvnList.length == dvnCount and assert the list is valid
+        if (_param.requiredDVNCount == NIL_DVN_COUNT || _param.requiredDVNCount == DEFAULT) {
+            if (_param.requiredDVNs.length != 0) revert LZ_RL_InvalidRequiredDVNCount();
+        } else {
+            if (_param.requiredDVNs.length != _param.requiredDVNCount || _param.requiredDVNCount > MAX_COUNT)
+                revert LZ_RL_InvalidRequiredDVNCount();
+            _assertNoDuplicates(_param.requiredDVNs);
+        }
+
+        // @dev optional dvns
+        // if optionalDVNCount == NONE, optionalDVNs list must be empty and threshold must be 0
+        // if optionalDVNCount == DEFAULT, optionalDVNs list must be empty and threshold must be 0
+        // otherwise, optionalDVNs.length == optionalDVNCount, threshold > 0 && threshold <= optionalDVNCount and assert the list is valid
+
+        // example use case: an oapp uses the DEFAULT 'required' but
+        //     a) use a custom 1/1 dvn (practically a required dvn), or
+        //     b) use a custom 2/3 dvn
+        if (_param.optionalDVNCount == NIL_DVN_COUNT || _param.optionalDVNCount == DEFAULT) {
+            if (_param.optionalDVNs.length != 0) revert LZ_RL_InvalidOptionalDVNCount();
+            if (_param.optionalDVNThreshold != 0) revert LZ_RL_InvalidOptionalDVNThreshold();
+        } else {
+            if (_param.optionalDVNs.length != _param.optionalDVNCount || _param.optionalDVNCount > MAX_COUNT)
+                revert LZ_RL_InvalidOptionalDVNCount();
+            if (_param.optionalDVNThreshold == 0 || _param.optionalDVNThreshold > _param.optionalDVNCount)
+                revert LZ_RL_InvalidOptionalDVNThreshold();
+            _assertNoDuplicates(_param.optionalDVNs);
+        }
+        // don't assert valid count here, as it needs to be validated along side default config
+
+        readLibConfigs[_oapp][_eid] = _param;
+    }
+
+    function _assertNoDuplicates(address[] memory _dvns) private pure {
+        address lastDVN = address(0);
+        for (uint256 i = 0; i < _dvns.length; i++) {
+            address dvn = _dvns[i];
+            if (dvn <= lastDVN) revert LZ_RL_Unsorted(); // to ensure no duplicates
+            lastDVN = dvn;
+        }
+    }
+}

package/contracts/uln/uln301/AddressSizeConfig.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+abstract contract AddressSizeConfig is Ownable {
+    // EndpointV1 is using bytes as address. this map is for address length assertion
+    mapping(uint32 dstEid => uint256 size) public addressSizes;
+
+    event AddressSizeSet(uint16 eid, uint256 size);
+
+    error AddressSizeConfig_InvalidAddressSize();
+    error AddressSizeConfig_AddressSizeAlreadySet();
+
+    function setAddressSize(uint16 _eid, uint256 _size) external onlyOwner {
+        if (_size > 32) revert AddressSizeConfig_InvalidAddressSize();
+        if (addressSizes[_eid] != 0) revert AddressSizeConfig_AddressSizeAlreadySet();
+        addressSizes[_eid] = _size;
+        emit AddressSizeSet(_eid, _size);
+    }
+}

package/contracts/uln/uln301/ReceiveLibBaseE1.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { ILayerZeroEndpoint } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+import { AddressCast } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol";
+
+import { AddressSizeConfig } from "./AddressSizeConfig.sol";
+import { MessageLibBase } from "../../MessageLibBase.sol";
+
+// only receiver function from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroMessagingLibrary.sol"
+// because we are separating the send and receive libraries
+interface ILayerZeroReceiveLibrary {
+    // setConfig / getConfig are User Application (UA) functions to specify Oracle, Relayer, blockConfirmations, libraryVersion
+    function setConfig(uint16 _chainId, address _userApplication, uint256 _configType, bytes calldata _config) external;
+
+    function getConfig(
+        uint16 _chainId,
+        address _userApplication,
+        uint256 _configType
+    ) external view returns (bytes memory);
+}
+
+struct SetDefaultExecutorParam {
+    uint32 eid;
+    address executor;
+}
+
+/// @dev receive-side message library base contract on endpoint v1.
+/// design:
+/// 1/ it provides an internal execute function that calls the endpoint. It enforces the path definition on V1.
+/// 2/ it provides interfaces to configure executors that is whitelisted to execute the msg to prevent grieving
+abstract contract ReceiveLibBaseE1 is MessageLibBase, AddressSizeConfig, ILayerZeroReceiveLibrary {
+    using AddressCast for bytes32;
+
+    mapping(address oapp => mapping(uint32 eid => address executor)) public executors;
+    mapping(uint32 eid => address executor) public defaultExecutors;
+
+    // this event is the same as the PacketDelivered event on EndpointV2
+    event PacketDelivered(Origin origin, address receiver);
+    event InvalidDst(
+        uint16 indexed srcChainId,
+        bytes32 srcAddress,
+        address indexed dstAddress,
+        uint64 nonce,
+        bytes32 payloadHash
+    );
+    event DefaultExecutorsSet(SetDefaultExecutorParam[] params);
+    event ExecutorSet(address oapp, uint32 eid, address executor);
+
+    error LZ_MessageLib_InvalidExecutor();
+    error LZ_MessageLib_OnlyExecutor();
+
+    constructor(address _endpoint, uint32 _localEid) MessageLibBase(_endpoint, _localEid) {}
+
+    function setDefaultExecutors(SetDefaultExecutorParam[] calldata _params) external onlyOwner {
+        for (uint256 i = 0; i < _params.length; ++i) {
+            SetDefaultExecutorParam calldata param = _params[i];
+            if (param.executor == address(0x0)) revert LZ_MessageLib_InvalidExecutor();
+            defaultExecutors[param.eid] = param.executor;
+        }
+        emit DefaultExecutorsSet(_params);
+    }
+
+    function getExecutor(address _oapp, uint32 _remoteEid) public view returns (address) {
+        address executor = executors[_oapp][_remoteEid];
+        return executor != address(0x0) ? executor : defaultExecutors[_remoteEid];
+    }
+
+    function _setExecutor(uint32 _remoteEid, address _oapp, address _executor) internal {
+        executors[_oapp][_remoteEid] = _executor;
+        emit ExecutorSet(_oapp, _remoteEid, _executor);
+    }
+
+    /// @dev this function change pack the path as required for EndpointV1
+    function _execute(
+        uint16 _srcEid,
+        bytes32 _sender,
+        address _receiver,
+        uint64 _nonce,
+        bytes memory _message,
+        uint256 _gasLimit
+    ) internal {
+        // if the executor is malicious, it can make the msg as a storedPayload or fail in the nonBlockingApp
+        // which might result in unintended behaviour and risks, like grieving.
+        // to err on the safe side, we should assert the executor here.
+        if (msg.sender != getExecutor(_receiver, _srcEid)) revert LZ_MessageLib_OnlyExecutor();
+
+        if (_receiver.code.length == 0) {
+            /// on chains where EOA has no codes, it will early return and emit InvalidDst event
+            // on chains where all address have codes, this will be skipped
+            emit InvalidDst(_srcEid, _sender, _receiver, _nonce, keccak256(_message));
+            return;
+        }
+
+        bytes memory pathData = abi.encodePacked(_sender.toBytes(addressSizes[_srcEid]), _receiver);
+        ILayerZeroEndpoint(endpoint).receivePayload(_srcEid, pathData, _receiver, _nonce, _gasLimit, _message);
+
+        Origin memory origin = Origin(_srcEid, _sender, _nonce);
+        emit PacketDelivered(origin, _receiver);
+    }
+}

package/contracts/uln/uln301/ReceiveUln301.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+import { IUltraLightNode301 } from "./interfaces/IUltraLightNode301.sol";
+import { ReceiveLibBaseE1 } from "./ReceiveLibBaseE1.sol";
+import { ReceiveUlnBase } from "../ReceiveUlnBase.sol";
+import { UlnConfig } from "../UlnBase.sol";
+
+/// @dev ULN301 will be deployed on EndpointV1 and is for backward compatibility with ULN302 on EndpointV2. 301 can talk to both 301 and 302
+/// @dev This is a gluing contract. It simply parses the requests and forward to the super.impl() accordingly.
+/// @dev In this case, it combines the logic of ReceiveUlnBase and ReceiveLibBaseE1
+contract ReceiveUln301 is IUltraLightNode301, ReceiveUlnBase, ReceiveLibBaseE1 {
+    using PacketV1Codec for bytes;
+    using SafeCast for uint32; // for chain ID uint32 to uint16 conversion
+
+    uint256 internal constant CONFIG_TYPE_EXECUTOR = 1;
+    uint256 internal constant CONFIG_TYPE_ULN = 2;
+
+    error LZ_ULN_InvalidConfigType(uint256 configType);
+
+    constructor(address _endpoint, uint32 _localEid) ReceiveLibBaseE1(_endpoint, _localEid) {}
+
+    // ============================ OnlyEndpoint ===================================
+
+    function setConfig(
+        uint16 _eid,
+        address _oapp,
+        uint256 _configType,
+        bytes calldata _config
+    ) external override onlyEndpoint {
+        _assertSupportedEid(_eid);
+        if (_configType == CONFIG_TYPE_EXECUTOR) {
+            _setExecutor(_eid, _oapp, abi.decode(_config, (address)));
+        } else if (_configType == CONFIG_TYPE_ULN) {
+            _setUlnConfig(_eid, _oapp, abi.decode(_config, (UlnConfig)));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    // ============================ External ===================================
+
+    /// @dev in 301, this is equivalent to execution as in Endpoint V2
+    /// @dev dont need to check endpoint verifiable here to save gas, as it will reverts if not verifiable.
+    function commitVerification(bytes calldata _packet, uint256 _gasLimit) external {
+        bytes calldata header = _packet.header();
+        _assertHeader(header, localEid);
+
+        // cache these values to save gas
+        address receiver = _packet.receiverB20();
+        uint16 srcEid = _packet.srcEid().toUint16();
+
+        UlnConfig memory config = getUlnConfig(receiver, srcEid);
+        _verifyAndReclaimStorage(config, keccak256(header), _packet.payloadHash());
+
+        // endpoint will revert if nonce != ++inboundNonce
+        _execute(srcEid, _packet.sender(), receiver, _packet.nonce(), _packet.message(), _gasLimit);
+    }
+
+    function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external {
+        _verify(_packetHeader, _payloadHash, _confirmations);
+    }
+
+    // ============================ View ===================================
+
+    function getConfig(uint16 _eid, address _oapp, uint256 _configType) external view override returns (bytes memory) {
+        if (_configType == CONFIG_TYPE_EXECUTOR) {
+            return abi.encode(getExecutor(_oapp, _eid));
+        } else if (_configType == CONFIG_TYPE_ULN) {
+            return abi.encode(getUlnConfig(_oapp, _eid));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (3, 0, 1);
+    }
+}

package/contracts/uln/uln301/ReceiveUln301View.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+
+import { ILayerZeroEndpoint } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+import { AddressCast } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+import { ExecutionState, EndpointV2View } from "@layerzerolabs/lz-evm-protocol-v2/contracts/EndpointV2View.sol";
+
+import { UlnConfig } from "../UlnBase.sol";
+
+enum VerificationState {
+    Verifying,
+    Verifiable,
+    Verified
+}
+
+interface IReceiveUln301 {
+    function assertHeader(bytes calldata _packetHeader, uint32 _localEid) external pure;
+
+    function addressSizes(uint32 _dstEid) external view returns (uint256);
+
+    function endpoint() external view returns (address);
+
+    function verifiable(
+        UlnConfig memory _config,
+        bytes32 _headerHash,
+        bytes32 _payloadHash
+    ) external view returns (bool);
+
+    function getUlnConfig(address _oapp, uint32 _remoteEid) external view returns (UlnConfig memory rtnConfig);
+}
+
+contract ReceiveUln301View is Initializable, Proxied {
+    using PacketV1Codec for bytes;
+    using AddressCast for bytes32;
+    using SafeCast for uint32;
+
+    ILayerZeroEndpoint public endpoint;
+    IReceiveUln301 public receiveUln301;
+    uint32 internal localEid;
+
+    function initialize(address _endpoint, uint32 _localEid, address _receiveUln301) external proxied initializer {
+        receiveUln301 = IReceiveUln301(_receiveUln301);
+        endpoint = ILayerZeroEndpoint(_endpoint);
+        localEid = _localEid;
+    }
+
+    function executable(bytes calldata _packetHeader, bytes32 _payloadHash) public view returns (ExecutionState) {
+        receiveUln301.assertHeader(_packetHeader, localEid);
+
+        address receiver = _packetHeader.receiverB20();
+        uint16 srcEid = _packetHeader.srcEid().toUint16();
+        uint64 nonce = _packetHeader.nonce();
+
+        // executed if nonce less than or equal to inboundNonce
+        bytes memory path = abi.encodePacked(
+            _packetHeader.sender().toBytes(receiveUln301.addressSizes(srcEid)),
+            receiver
+        );
+        if (nonce <= endpoint.getInboundNonce(srcEid, path)) return ExecutionState.Executed;
+
+        // executable if not executed and _verified
+        if (
+            receiveUln301.verifiable(
+                receiveUln301.getUlnConfig(receiver, srcEid),
+                keccak256(_packetHeader),
+                _payloadHash
+            )
+        ) {
+            return ExecutionState.Executable;
+        }
+
+        return ExecutionState.NotExecutable;
+    }
+
+    /// @dev keeping the same interface as 302
+    /// @dev a verifiable message requires it to be ULN verifiable only, excluding the endpoint verifiable check
+    function verifiable(bytes calldata _packetHeader, bytes32 _payloadHash) external view returns (VerificationState) {
+        if (executable(_packetHeader, _payloadHash) == ExecutionState.NotExecutable) {
+            return VerificationState.Verifying;
+        }
+        return VerificationState.Verified;
+    }
+}