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

package/contracts/uln/uln301/SendLibBaseE1.sol

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { AddressCast } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol";
+import { GUID } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/GUID.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { IMessageLibE1 } from "./interfaces/IMessageLibE1.sol";
+import { ITreasuryFeeHandler } from "./interfaces/ITreasuryFeeHandler.sol";
+import { INonceContract } from "./interfaces/INonceContract.sol";
+import { SendLibBase, WorkerOptions, ExecutorConfig } from "../../SendLibBase.sol";
+import { AddressSizeConfig } from "./AddressSizeConfig.sol";
+
+/// @dev send-side message library base contract on endpoint v1.
+/// design:
+/// 1/ it enforces the path definition on V1 and interacts with the nonce contract
+/// 2/ quote: first executor, then verifier (e.g. DVNs), then treasury
+/// 3/ send: first executor, then verifier (e.g. DVNs), then treasury. the treasury pay much be DoS-proof
+abstract contract SendLibBaseE1 is SendLibBase, AddressSizeConfig, IMessageLibE1 {
+    INonceContract public immutable nonceContract;
+    ITreasuryFeeHandler public immutable treasuryFeeHandler;
+
+    // config
+    address internal lzToken;
+
+    // this event should be identical to the one on Endpoint V2
+    event PacketSent(bytes encodedPayload, bytes options, uint256 nativeFee, uint256 lzTokenFee);
+    event NativeFeeWithdrawn(address user, address receiver, uint256 amount);
+    event LzTokenSet(address token);
+
+    constructor(
+        address _endpoint,
+        uint256 _treasuryGasLimit,
+        uint256 _treasuryNativeFeeCap,
+        address _nonceContract,
+        uint32 _localEid,
+        address _treasuryFeeHandler
+    ) SendLibBase(_endpoint, _localEid, _treasuryGasLimit, _treasuryNativeFeeCap) {
+        nonceContract = INonceContract(_nonceContract);
+        treasuryFeeHandler = ITreasuryFeeHandler(_treasuryFeeHandler);
+    }
+
+    // ======================= OnlyEndpoint =======================
+    /// @dev the abstract process for send() is:
+    /// 1/ pay workers, which includes the executor and the validation workers
+    /// 2/ pay treasury
+    /// 3/ in EndpointV1, here we handle the fees and refunds
+    function send(
+        address _sender,
+        uint64, // _nonce
+        uint16 _dstEid,
+        bytes calldata _path, // remoteAddress + localAddress
+        bytes calldata _message,
+        address payable _refundAddress,
+        address _lzTokenPaymentAddress,
+        bytes calldata _options
+    ) external payable onlyEndpoint {
+        (bytes memory encodedPacket, uint256 totalNativeFee) = _payWorkers(_sender, _dstEid, _path, _message, _options);
+
+        // quote treasury fee
+        uint32 dstEid = _dstEid; // stack too deep
+        address sender = _sender; // stack too deep
+        bool payInLzToken = _lzTokenPaymentAddress != address(0x0) && address(lzToken) != address(0x0);
+        (uint256 treasuryNativeFee, uint256 lzTokenFee) = _payTreasury(sender, dstEid, totalNativeFee, payInLzToken);
+        totalNativeFee += treasuryNativeFee;
+
+        // pay native fee
+        // assert the user has attached enough native token for this address
+        if (msg.value < totalNativeFee) revert LZ_MessageLib_InsufficientMsgValue();
+        // refund if they send too much
+        uint256 refundAmt = msg.value - totalNativeFee;
+        if (refundAmt > 0) {
+            Transfer.native(_refundAddress, refundAmt);
+        }
+
+        // pay lz token fee if needed
+        if (lzTokenFee > 0) {
+            // in v2, we let user pass a payInLzToken boolean but always charging the sender
+            // likewise in v1, if _lzTokenPaymentAddress is passed, it must be the sender
+            if (_lzTokenPaymentAddress != sender) revert LZ_MessageLib_LzTokenPaymentAddressMustBeSender();
+            _payLzTokenFee(sender, lzTokenFee);
+        }
+
+        emit PacketSent(encodedPacket, _options, totalNativeFee, lzTokenFee);
+    }
+
+    // ======================= OnlyOwner =======================
+    function setLzToken(address _lzToken) external onlyOwner {
+        lzToken = _lzToken;
+        emit LzTokenSet(_lzToken);
+    }
+
+    function setTreasury(address _treasury) external onlyOwner {
+        _setTreasury(_treasury);
+    }
+
+    // ======================= External =======================
+    function withdrawFee(address _to, uint256 _amount) external {
+        _debitFee(_amount);
+        Transfer.native(_to, _amount);
+        emit NativeFeeWithdrawn(msg.sender, _to, _amount);
+    }
+
+    // ======================= View =======================
+    function estimateFees(
+        uint16 _dstEid,
+        address _sender,
+        bytes calldata _message,
+        bool _payInLzToken,
+        bytes calldata _options
+    ) external view returns (uint256 nativeFee, uint256 lzTokenFee) {
+        return _quote(_sender, _dstEid, _message.length, _payInLzToken, _options);
+    }
+
+    // ======================= Internal =======================
+    /// @dev path = remoteAddress + localAddress.
+    function _assertPath(address _sender, bytes calldata _path, uint256 remoteAddressSize) internal pure {
+        if (_path.length != 20 + remoteAddressSize) revert LZ_MessageLib_InvalidPath();
+        address srcInPath = AddressCast.toAddress(_path[remoteAddressSize:]);
+        if (_sender != srcInPath) revert LZ_MessageLib_InvalidSender();
+    }
+
+    function _payLzTokenFee(address _sender, uint256 _lzTokenFee) internal {
+        treasuryFeeHandler.payFee(
+            lzToken,
+            _sender,
+            _lzTokenFee, // the supplied fee is always equal to the required fee
+            _lzTokenFee,
+            treasury
+        );
+    }
+
+    /// @dev outbound does three things
+    /// @dev 1) asserts path
+    /// @dev 2) increments the nonce
+    /// @dev 3) assemble packet
+    /// @return packet to be sent to workers
+    function _outbound(
+        address _sender,
+        uint16 _dstEid,
+        bytes calldata _path,
+        bytes calldata _message
+    ) internal returns (Packet memory packet) {
+        // assert toAddress size
+        uint256 remoteAddressSize = addressSizes[_dstEid];
+        if (remoteAddressSize == 0) revert LZ_MessageLib_InvalidPath();
+        _assertPath(_sender, _path, remoteAddressSize);
+
+        // increment nonce
+        uint64 nonce = nonceContract.increment(_dstEid, _sender, _path);
+
+        bytes32 receiver = AddressCast.toBytes32(_path[0:remoteAddressSize]);
+
+        bytes32 guid = GUID.generate(nonce, localEid, _sender, _dstEid, receiver);
+
+        // assemble packet
+        packet = Packet(nonce, localEid, _sender, _dstEid, receiver, guid, _message);
+    }
+
+    /// 1/ handle executor
+    /// 2/ handle other workers
+    function _payWorkers(
+        address _sender,
+        uint16 _dstEid,
+        bytes calldata _path,
+        bytes calldata _message,
+        bytes calldata _options
+    ) internal returns (bytes memory encodedPacket, uint256 totalNativeFee) {
+        Packet memory packet = _outbound(_sender, _dstEid, _path, _message);
+
+        // split workers options
+        (bytes memory executorOptions, WorkerOptions[] memory verificationOptions) = _splitOptions(_options);
+
+        // handle executor
+        ExecutorConfig memory config = getExecutorConfig(_sender, _dstEid);
+        uint256 msgSize = packet.message.length;
+        _assertMessageSize(msgSize, config.maxMessageSize);
+        totalNativeFee += _payExecutor(config.executor, packet.dstEid, packet.sender, msgSize, executorOptions);
+
+        // handle other workers
+        (uint256 verifierFee, bytes memory packetBytes) = _payVerifier(packet, verificationOptions);
+        totalNativeFee += verifierFee;
+
+        encodedPacket = packetBytes;
+    }
+
+    // ======================= Virtual =======================
+    function _payVerifier(
+        Packet memory _packet, // packet is assembled in memory for endpoint-v1. so the location can not be calldata
+        WorkerOptions[] memory _options
+    ) internal virtual returns (uint256 otherWorkerFees, bytes memory encodedPacket);
+}

package/contracts/uln/uln301/SendUln301.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+
+import { ExecutorConfig, WorkerOptions } from "../../SendLibBase.sol";
+import { SendLibBaseE1 } from "./SendLibBaseE1.sol";
+import { SendUlnBase } from "../SendUlnBase.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 SendUlnBase and SendLibBaseE1
+contract SendUln301 is SendUlnBase, SendLibBaseE1 {
+    uint256 internal constant CONFIG_TYPE_EXECUTOR = 1;
+    uint256 internal constant CONFIG_TYPE_ULN = 2;
+
+    error LZ_ULN_InvalidConfigType(uint256 configType);
+
+    constructor(
+        address _endpoint,
+        uint256 _treasuryGasLimit,
+        uint256 _treasuryGasForFeeCap,
+        address _nonceContract,
+        uint32 _localEid,
+        address _treasuryFeeHandler
+    )
+        SendLibBaseE1(
+            _endpoint,
+            _treasuryGasLimit,
+            _treasuryGasForFeeCap,
+            _nonceContract,
+            _localEid,
+            _treasuryFeeHandler
+        )
+    {}
+
+    // ============================ OnlyEndpoint ===================================
+
+    function setConfig(
+        uint16 _eid,
+        address _oapp,
+        uint256 _configType,
+        bytes calldata _config
+    ) external override onlyEndpoint {
+        _assertSupportedEid(_eid);
+        if (_configType == CONFIG_TYPE_EXECUTOR) {
+            _setExecutorConfig(_eid, _oapp, abi.decode(_config, (ExecutorConfig)));
+        } else if (_configType == CONFIG_TYPE_ULN) {
+            _setUlnConfig(_eid, _oapp, abi.decode(_config, (UlnConfig)));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    // ============================ View ===================================
+
+    function getConfig(uint16 _eid, address _oapp, uint256 _configType) external view override returns (bytes memory) {
+        if (_configType == CONFIG_TYPE_EXECUTOR) {
+            return abi.encode(getExecutorConfig(_oapp, _eid));
+        } else if (_configType == CONFIG_TYPE_ULN) {
+            return abi.encode(getUlnConfig(_oapp, _eid));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    function version() external pure override returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (3, 0, 1);
+    }
+
+    function isSupportedEid(uint32 _eid) external view returns (bool) {
+        return _isSupportedEid(_eid);
+    }
+
+    // ============================ Internal ===================================
+
+    function _quoteVerifier(
+        address _sender,
+        uint32 _dstEid,
+        WorkerOptions[] memory _options
+    ) internal view override returns (uint256) {
+        return _quoteDVNs(_sender, _dstEid, _options);
+    }
+
+    function _payVerifier(
+        Packet memory _packet,
+        WorkerOptions[] memory _options
+    ) internal virtual override returns (uint256 otherWorkerFees, bytes memory encodedPacket) {
+        (otherWorkerFees, encodedPacket) = _payDVNs(fees, _packet, _options);
+    }
+
+    function _splitOptions(
+        bytes calldata _options
+    ) internal pure override returns (bytes memory, WorkerOptions[] memory) {
+        return _splitUlnOptions(_options);
+    }
+}

package/contracts/uln/uln301/TreasuryFeeHandler.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import { ILayerZeroEndpoint } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+
+import { ITreasuryFeeHandler } from "./interfaces/ITreasuryFeeHandler.sol";
+
+contract TreasuryFeeHandler is ITreasuryFeeHandler {
+    using SafeERC20 for IERC20;
+
+    ILayerZeroEndpoint public immutable endpoint;
+
+    error LZ_TreasuryFeeHandler_OnlySendLibrary();
+    error LZ_TreasuryFeeHandler_OnlyOnSending();
+    error LZ_TreasuryFeeHandler_InvalidAmount(uint256 required, uint256 supplied);
+
+    constructor(address _endpoint) {
+        endpoint = ILayerZeroEndpoint(_endpoint);
+    }
+
+    // @dev payer of layerzero token must be sender
+    function payFee(
+        address _lzToken,
+        address _sender,
+        uint256 _required,
+        uint256 _supplied,
+        address _treasury
+    ) external {
+        // only sender's message library can call this function and only when sending a payload
+        if (endpoint.getSendLibraryAddress(_sender) != msg.sender) revert LZ_TreasuryFeeHandler_OnlySendLibrary();
+        if (!endpoint.isSendingPayload()) revert LZ_TreasuryFeeHandler_OnlyOnSending();
+        if (_required > _supplied) revert LZ_TreasuryFeeHandler_InvalidAmount(_required, _supplied);
+
+        // send lz token fee to the treasury directly
+        IERC20(_lzToken).safeTransferFrom(_sender, _treasury, _required);
+    }
+}

package/contracts/uln/uln301/interfaces/IMessageLibE1.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { ILayerZeroMessagingLibrary } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroMessagingLibrary.sol";
+
+/// extends ILayerZeroMessagingLibrary instead of ILayerZeroMessagingLibraryV2 for reducing the contract size
+interface IMessageLibE1 is ILayerZeroMessagingLibrary {
+    error LZ_MessageLib_InvalidPath();
+    error LZ_MessageLib_InvalidSender();
+    error LZ_MessageLib_InsufficientMsgValue();
+    error LZ_MessageLib_LzTokenPaymentAddressMustBeSender();
+
+    function setLzToken(address _lzToken) external;
+
+    function setTreasury(address _treasury) external;
+
+    function withdrawFee(address _to, uint256 _amount) external;
+
+    // message libs of same major version are compatible
+    function version() external view returns (uint64 major, uint8 minor, uint8 endpointVersion);
+}

package/contracts/uln/uln301/interfaces/INonceContract.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface INonceContract {
+    function increment(uint16 _chainId, address _ua, bytes calldata _path) external returns (uint64);
+}

package/contracts/uln/uln301/interfaces/ITreasuryFeeHandler.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ITreasuryFeeHandler {
+    function payFee(
+        address _lzToken,
+        address _sender,
+        uint256 _required,
+        uint256 _supplied,
+        address _treasury
+    ) external;
+}

package/contracts/uln/uln301/interfaces/IUltraLightNode301.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IUltraLightNode301 {
+    function commitVerification(bytes calldata _packet, uint256 _gasLimit) external;
+}

package/contracts/uln/uln301/mocks/NonceContractMock.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import { ILayerZeroEndpoint } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+
+contract NonceContractMock {
+    error OnlySendLibrary();
+
+    ILayerZeroEndpoint public immutable endpoint;
+    mapping(uint16 dstEid => mapping(bytes path => uint64 nonce)) public outboundNonce;
+
+    constructor(address _endpoint) {
+        endpoint = ILayerZeroEndpoint(_endpoint);
+    }
+
+    function increment(uint16 _chainId, address _ua, bytes calldata _path) external returns (uint64) {
+        if (msg.sender != endpoint.getSendLibraryAddress(_ua)) {
+            revert OnlySendLibrary();
+        }
+        return ++outboundNonce[_chainId][_path];
+    }
+}

package/contracts/uln/uln302/ReceiveUln302.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+import { SetConfigParam } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";
+import { ILayerZeroEndpointV2, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+import { IReceiveUlnE2 } from "../interfaces/IReceiveUlnE2.sol";
+import { ReceiveUlnBase } from "../ReceiveUlnBase.sol";
+import { ReceiveLibBaseE2 } from "../../ReceiveLibBaseE2.sol";
+import { UlnConfig } from "../UlnBase.sol";
+
+/// @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 ReceiveLibBaseE2
+contract ReceiveUln302 is IReceiveUlnE2, ReceiveUlnBase, ReceiveLibBaseE2 {
+    using PacketV1Codec for bytes;
+
+    /// @dev CONFIG_TYPE_ULN=2 here to align with SendUln302/ReceiveUln302/ReceiveUln301
+    uint32 internal constant CONFIG_TYPE_ULN = 2;
+
+    error LZ_ULN_InvalidConfigType(uint32 configType);
+
+    constructor(address _endpoint) ReceiveLibBaseE2(_endpoint) {}
+
+    function supportsInterface(bytes4 _interfaceId) public view override returns (bool) {
+        return _interfaceId == type(IReceiveUlnE2).interfaceId || super.supportsInterface(_interfaceId);
+    }
+
+    // ============================ OnlyEndpoint ===================================
+
+    // only the ULN config on the receive side
+    function setConfig(address _oapp, SetConfigParam[] calldata _params) external override onlyEndpoint {
+        for (uint256 i = 0; i < _params.length; i++) {
+            SetConfigParam calldata param = _params[i];
+            _assertSupportedEid(param.eid);
+            if (param.configType == CONFIG_TYPE_ULN) {
+                _setUlnConfig(param.eid, _oapp, abi.decode(param.config, (UlnConfig)));
+            } else {
+                revert LZ_ULN_InvalidConfigType(param.configType);
+            }
+        }
+    }
+
+    // ============================ External ===================================
+
+    /// @dev dont need to check endpoint verifiable here to save gas, as it will reverts if not verifiable.
+    function commitVerification(bytes calldata _packetHeader, bytes32 _payloadHash) external {
+        _assertHeader(_packetHeader, localEid);
+
+        // cache these values to save gas
+        address receiver = _packetHeader.receiverB20();
+        uint32 srcEid = _packetHeader.srcEid();
+
+        UlnConfig memory config = getUlnConfig(receiver, srcEid);
+        _verifyAndReclaimStorage(config, keccak256(_packetHeader), _payloadHash);
+
+        Origin memory origin = Origin(srcEid, _packetHeader.sender(), _packetHeader.nonce());
+        // endpoint will revert if nonce <= lazyInboundNonce
+        ILayerZeroEndpointV2(endpoint).verify(origin, receiver, _payloadHash);
+    }
+
+    /// @dev for dvn to verify the payload
+    function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external {
+        _verify(_packetHeader, _payloadHash, _confirmations);
+    }
+
+    // ============================ View ===================================
+
+    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view override returns (bytes memory) {
+        if (_configType == CONFIG_TYPE_ULN) {
+            return abi.encode(getUlnConfig(_oapp, _eid));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    function isSupportedEid(uint32 _eid) external view override returns (bool) {
+        return _isSupportedEid(_eid);
+    }
+
+    function version() external pure override returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (3, 0, 2);
+    }
+}

package/contracts/uln/uln302/ReceiveUln302View.sol

@@ -0,0 +1,89 @@
+// 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 { UlnConfig } from "../UlnBase.sol";
+
+enum VerificationState {
+    Verifying,
+    Verifiable,
+    Verified,
+    NotInitializable
+}
+
+interface IReceiveUln302 {
+    function assertHeader(bytes calldata _packetHeader, uint32 _localEid) external pure;
+
+    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 ReceiveUln302View is EndpointV2ViewUpgradeable, Proxied {
+    using PacketV1Codec for bytes;
+
+    IReceiveUln302 public receiveUln302;
+    uint32 internal localEid;
+
+    function initialize(address _endpoint, address _receiveUln302) external proxied initializer {
+        __EndpointV2View_init(_endpoint);
+        receiveUln302 = IReceiveUln302(_receiveUln302);
+        localEid = endpoint.eid();
+    }
+
+    /// @dev a ULN verifiable requires it to be endpoint verifiable and committable
+    function verifiable(bytes calldata _packetHeader, bytes32 _payloadHash) external view returns (VerificationState) {
+        receiveUln302.assertHeader(_packetHeader, localEid);
+
+        address receiver = _packetHeader.receiverB20();
+
+        Origin memory origin = Origin(_packetHeader.srcEid(), _packetHeader.sender(), _packetHeader.nonce());
+
+        // check endpoint initializable
+        if (!initializable(origin, receiver)) {
+            return VerificationState.NotInitializable;
+        }
+
+        // check endpoint verifiable
+        if (!_endpointVerifiable(origin, receiver, _payloadHash)) {
+            return VerificationState.Verified;
+        }
+
+        // check uln verifiable
+        if (
+            receiveUln302.verifiable(
+                receiveUln302.getUlnConfig(receiver, origin.srcEid),
+                keccak256(_packetHeader),
+                _payloadHash
+            )
+        ) {
+            return VerificationState.Verifiable;
+        }
+        return VerificationState.Verifying;
+    }
+
+    /// @dev checks for endpoint verifiable and endpoint has payload hash
+    function _endpointVerifiable(
+        Origin memory origin,
+        address _receiver,
+        bytes32 _payloadHash
+    ) internal view returns (bool) {
+        // check endpoint verifiable
+        if (!verifiable(origin, _receiver, address(receiveUln302), _payloadHash)) return false;
+
+        // if endpoint.verifiable, also 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 false;
+
+        return true;
+    }
+}

package/contracts/uln/uln302/SendUln302.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { SetConfigParam } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol";
+
+import { ExecutorConfig } from "../../SendLibBase.sol";
+import { SendLibBaseE2, WorkerOptions } from "../../SendLibBaseE2.sol";
+import { UlnConfig } from "../UlnBase.sol";
+import { SendUlnBase } from "../SendUlnBase.sol";
+
+/// @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 SendUlnBase and SendLibBaseE2
+contract SendUln302 is SendUlnBase, SendLibBaseE2 {
+    uint32 internal constant CONFIG_TYPE_EXECUTOR = 1;
+    uint32 internal constant CONFIG_TYPE_ULN = 2;
+
+    error LZ_ULN_InvalidConfigType(uint32 configType);
+
+    constructor(
+        address _endpoint,
+        uint256 _treasuryGasLimit,
+        uint256 _treasuryGasForFeeCap
+    ) SendLibBaseE2(_endpoint, _treasuryGasLimit, _treasuryGasForFeeCap) {}
+
+    // ============================ OnlyEndpoint ===================================
+
+    // on the send side the user can config both the executor and the ULN
+    function setConfig(address _oapp, SetConfigParam[] calldata _params) external override onlyEndpoint {
+        for (uint256 i = 0; i < _params.length; i++) {
+            SetConfigParam calldata param = _params[i];
+            _assertSupportedEid(param.eid);
+            if (param.configType == CONFIG_TYPE_EXECUTOR) {
+                _setExecutorConfig(param.eid, _oapp, abi.decode(param.config, (ExecutorConfig)));
+            } else if (param.configType == CONFIG_TYPE_ULN) {
+                _setUlnConfig(param.eid, _oapp, abi.decode(param.config, (UlnConfig)));
+            } else {
+                revert LZ_ULN_InvalidConfigType(param.configType);
+            }
+        }
+    }
+
+    // ============================ View ===================================
+
+    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view override returns (bytes memory) {
+        if (_configType == CONFIG_TYPE_EXECUTOR) {
+            return abi.encode(getExecutorConfig(_oapp, _eid));
+        } else if (_configType == CONFIG_TYPE_ULN) {
+            return abi.encode(getUlnConfig(_oapp, _eid));
+        } else {
+            revert LZ_ULN_InvalidConfigType(_configType);
+        }
+    }
+
+    function version() external pure override returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (3, 0, 2);
+    }
+
+    function isSupportedEid(uint32 _eid) external view override returns (bool) {
+        return _isSupportedEid(_eid);
+    }
+
+    // ============================ Internal ===================================
+
+    function _quoteVerifier(
+        address _sender,
+        uint32 _dstEid,
+        WorkerOptions[] memory _options
+    ) internal view override returns (uint256) {
+        return _quoteDVNs(_sender, _dstEid, _options);
+    }
+
+    function _payVerifier(
+        Packet calldata _packet,
+        WorkerOptions[] memory _options
+    ) internal override returns (uint256 otherWorkerFees, bytes memory encodedPacket) {
+        (otherWorkerFees, encodedPacket) = _payDVNs(fees, _packet, _options);
+    }
+
+    function _splitOptions(
+        bytes calldata _options
+    ) internal pure override returns (bytes memory, WorkerOptions[] memory) {
+        return _splitUlnOptions(_options);
+    }
+}