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

package/README.md

@@ -0,0 +1,15 @@
+# `@layerzerolabs/protocol-v2-messagelib-evm-contracts`
+
+LayerZero V2 EVM message libraries (ULN 301/302, read library), DVN, executor, price feed and treasury contracts. Its sources import `@layerzerolabs/lz-evm-protocol-v2` and `@layerzerolabs/lz-evm-v1-0.7`, which resolve to the workspace copies through package aliases, so the source names, and with them the metadata hashes, stay as published.
+
+Copied byte for byte from `@layerzerolabs/lz-evm-messagelib-v2` (`packages/layerzero-v2/evm/messagelib`) in the old LayerZero-Labs/monorepo at `origin/cb/executor-upgrade` (`d976cafeaf`). Only `contracts/` and the Foundry tests are copied; the old deploy scripts, deployment records, typechain bindings and Hardhat tests are not.
+
+## Build
+
+`pnpm build` compiles with the old compiler settings (`hardhat.config.cjs`) into `artifacts/` (EVM), `artifacts-zk/` (zkSync) and `artifacts-tron/` (Tron), which the package publishes for consumers to read by path, e.g. `@layerzerolabs/protocol-v2-messagelib-evm-contracts/artifacts/contracts/<Source>.sol/<Contract>.json`.
+
+`../scripts/compare-artifacts.mjs` compares the compiled bytecode with the artifacts the old monorepo published.
+
+## Test
+
+`pnpm test` runs the Foundry tests.

package/contracts/Executor.sol

@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+import { IUltraLightNode301 } from "./uln/uln301/interfaces/IUltraLightNode301.sol";
+import { IExecutor } from "./interfaces/IExecutor.sol";
+import { IExecutorFeeLib } from "./interfaces/IExecutorFeeLib.sol";
+import { WorkerUpgradeable } from "./upgradeable/WorkerUpgradeable.sol";
+
+interface ILayerZeroEndpointV2 {
+    function eid() external view returns (uint32);
+
+    function lzReceive(
+        Origin calldata _origin,
+        address _receiver,
+        bytes32 _guid,
+        bytes calldata _message,
+        bytes calldata _extraData
+    ) external payable;
+
+    function lzReceiveAlert(
+        Origin calldata _origin,
+        address _receiver,
+        bytes32 _guid,
+        uint256 _gas,
+        uint256 _value,
+        bytes calldata _message,
+        bytes calldata _extraData,
+        bytes calldata _reason
+    ) external;
+
+    function lzCompose(
+        address _from,
+        address _to,
+        bytes32 _guid,
+        uint16 _index,
+        bytes calldata _message,
+        bytes calldata _extraData
+    ) external payable;
+
+    function lzComposeAlert(
+        address _from,
+        address _to,
+        bytes32 _guid,
+        uint16 _index,
+        uint256 _gas,
+        uint256 _value,
+        bytes calldata _message,
+        bytes calldata _extraData,
+        bytes calldata _reason
+    ) external;
+}
+
+contract Executor is WorkerUpgradeable, ReentrancyGuardUpgradeable, Proxied, IExecutor {
+    using PacketV1Codec for bytes;
+
+    mapping(uint32 dstEid => DstConfig) public dstConfig;
+
+    // endpoint v2
+    address public endpoint;
+    uint32 public localEidV2;
+
+    // endpoint v1
+    address public receiveUln301;
+
+    event ReceiveUln301Set(address receiveUln301);
+    event PriceFloorWhitelistSet(address indexed sender, bool whitelisted);
+
+    // Senders quoted and charged the multiplier price, with no USD floor.
+    mapping(address sender => bool whitelisted) public priceFloorWhitelist;
+
+    struct SetPriceFloorWhitelistParam {
+        address sender;
+        bool whitelisted;
+    }
+
+    function initialize(
+        address _endpoint,
+        address _receiveUln301,
+        address[] memory _messageLibs,
+        address _priceFeed,
+        address _roleAdmin,
+        address[] memory _admins
+    ) external proxied initializer {
+        __ReentrancyGuard_init();
+        __Worker_init(_messageLibs, _priceFeed, 12000, _roleAdmin, _admins);
+        endpoint = _endpoint;
+        localEidV2 = ILayerZeroEndpointV2(_endpoint).eid();
+        receiveUln301 = _receiveUln301;
+    }
+
+    function onUpgrade(address _receiveUln301) external proxied {
+        receiveUln301 = _receiveUln301;
+    }
+
+    // --- Admin ---
+    function setDstConfig(DstConfigParam[] memory _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; i++) {
+            DstConfigParam memory param = _params[i];
+            dstConfig[param.dstEid] = DstConfig(
+                param.lzReceiveBaseGas,
+                param.multiplierBps,
+                param.floorMarginUSD,
+                param.nativeCap,
+                param.lzComposeBaseGas
+            );
+        }
+        emit DstConfigSet(_params);
+    }
+
+    function setReceiveUln301(address _receiveUln301) external onlyRole(ADMIN_ROLE) {
+        receiveUln301 = _receiveUln301;
+        emit ReceiveUln301Set(_receiveUln301);
+    }
+
+    /// @notice Mark senders that pay the default multiplier price and skip the USD price floor.
+    function setPriceFloorWhitelist(SetPriceFloorWhitelistParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; i++) {
+            SetPriceFloorWhitelistParam calldata param = _params[i];
+            priceFloorWhitelist[param.sender] = param.whitelisted;
+            emit PriceFloorWhitelistSet(param.sender, param.whitelisted);
+        }
+    }
+
+    function nativeDrop(
+        Origin calldata _origin,
+        uint32 _dstEid,
+        address _oapp,
+        NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit
+    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {
+        _nativeDrop(_origin, _dstEid, _oapp, _nativeDropParams, _nativeDropGasLimit);
+    }
+
+    function nativeDropAndExecute301(
+        Origin calldata _origin,
+        NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit,
+        bytes calldata _packet,
+        uint256 _gasLimit
+    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {
+        _nativeDrop(_origin, _packet.dstEid(), _packet.receiverB20(), _nativeDropParams, _nativeDropGasLimit);
+        IUltraLightNode301(receiveUln301).commitVerification(_packet, _gasLimit);
+    }
+
+    function execute301(bytes calldata _packet, uint256 _gasLimit) external onlyRole(ADMIN_ROLE) nonReentrant {
+        IUltraLightNode301(receiveUln301).commitVerification(_packet, _gasLimit);
+    }
+
+    function execute302(ExecutionParams calldata _executionParams) external payable onlyRole(ADMIN_ROLE) nonReentrant {
+        try
+            ILayerZeroEndpointV2(endpoint).lzReceive{ value: msg.value, gas: _executionParams.gasLimit }(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.message,
+                _executionParams.extraData
+            )
+        {
+            // do nothing
+        } catch (bytes memory reason) {
+            ILayerZeroEndpointV2(endpoint).lzReceiveAlert(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.gasLimit,
+                msg.value,
+                _executionParams.message,
+                _executionParams.extraData,
+                reason
+            );
+        }
+    }
+
+    function compose302(
+        address _from,
+        address _to,
+        bytes32 _guid,
+        uint16 _index,
+        bytes calldata _message,
+        bytes calldata _extraData,
+        uint256 _gasLimit
+    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {
+        try
+            ILayerZeroEndpointV2(endpoint).lzCompose{ value: msg.value, gas: _gasLimit }(
+                _from,
+                _to,
+                _guid,
+                _index,
+                _message,
+                _extraData
+            )
+        {
+            // do nothing
+        } catch (bytes memory reason) {
+            ILayerZeroEndpointV2(endpoint).lzComposeAlert(
+                _from,
+                _to,
+                _guid,
+                _index,
+                _gasLimit,
+                msg.value,
+                _message,
+                _extraData,
+                reason
+            );
+        }
+    }
+
+    function nativeDropAndExecute302(
+        NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit,
+        ExecutionParams calldata _executionParams
+    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {
+        uint256 spent = _nativeDrop(
+            _executionParams.origin,
+            localEidV2,
+            _executionParams.receiver,
+            _nativeDropParams,
+            _nativeDropGasLimit
+        );
+
+        uint256 value = msg.value - spent;
+        try
+            ILayerZeroEndpointV2(endpoint).lzReceive{ value: value, gas: _executionParams.gasLimit }(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.message,
+                _executionParams.extraData
+            )
+        {
+            // do nothing
+        } catch (bytes memory reason) {
+            ILayerZeroEndpointV2(endpoint).lzReceiveAlert(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.gasLimit,
+                value,
+                _executionParams.message,
+                _executionParams.extraData,
+                reason
+            );
+        }
+    }
+
+    // --- Message Lib ---
+    function assignJob(
+        uint32 _dstEid,
+        address _sender,
+        uint256 _calldataSize,
+        bytes calldata _options
+    ) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) whenNotPaused returns (uint256 fee) {
+        IExecutorFeeLib.FeeParams memory params = IExecutorFeeLib.FeeParams(
+            priceFeed,
+            _dstEid,
+            _sender,
+            _calldataSize,
+            defaultMultiplierBps
+        );
+        fee = IExecutorFeeLib(workerFeeLib).getFeeOnSend(params, _configForSender(_dstEid, _sender), _options);
+    }
+
+    // assignJob for ReadLib
+    function assignJob(
+        address _sender,
+        bytes calldata _options
+    ) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) whenNotPaused returns (uint256 fee) {
+        IExecutorFeeLib.FeeParamsForRead memory params = IExecutorFeeLib.FeeParamsForRead(
+            priceFeed,
+            _sender,
+            defaultMultiplierBps
+        );
+        fee = IExecutorFeeLib(workerFeeLib).getFeeOnSend(params, _configForSender(localEidV2, _sender), _options);
+    }
+
+    // --- Only ACL ---
+    function getFee(
+        uint32 _dstEid,
+        address _sender,
+        uint256 _calldataSize,
+        bytes calldata _options
+    ) external view onlyAcl(_sender) whenNotPaused returns (uint256 fee) {
+        IExecutorFeeLib.FeeParams memory params = IExecutorFeeLib.FeeParams(
+            priceFeed,
+            _dstEid,
+            _sender,
+            _calldataSize,
+            defaultMultiplierBps
+        );
+        fee = IExecutorFeeLib(workerFeeLib).getFee(params, _configForSender(_dstEid, _sender), _options);
+    }
+
+    function getFee(
+        address _sender,
+        bytes calldata _options
+    ) external view onlyAcl(_sender) whenNotPaused returns (uint256 fee) {
+        IExecutorFeeLib.FeeParamsForRead memory params = IExecutorFeeLib.FeeParamsForRead(
+            priceFeed,
+            _sender,
+            defaultMultiplierBps
+        );
+        fee = IExecutorFeeLib(workerFeeLib).getFee(params, _configForSender(localEidV2, _sender), _options);
+    }
+
+    /// @dev Whitelisted senders keep multiplier pricing and have the USD floor cleared.
+    function _configForSender(uint32 _dstEid, address _sender) internal view returns (DstConfig memory config) {
+        config = dstConfig[_dstEid];
+        if (priceFloorWhitelist[_sender]) {
+            config.floorMarginUSD = 0;
+        }
+    }
+
+    function _nativeDrop(
+        Origin calldata _origin,
+        uint32 _dstEid,
+        address _oapp,
+        NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit
+    ) internal returns (uint256 spent) {
+        bool[] memory success = new bool[](_nativeDropParams.length);
+        for (uint256 i = 0; i < _nativeDropParams.length; i++) {
+            NativeDropParams memory param = _nativeDropParams[i];
+
+            (bool sent, ) = param.receiver.call{ value: param.amount, gas: _nativeDropGasLimit }("");
+
+            success[i] = sent;
+            spent += param.amount;
+        }
+        emit NativeDropApplied(_origin, _dstEid, _oapp, _nativeDropParams, success);
+    }
+}

package/contracts/ExecutorFeeLib.sol

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { ILayerZeroPriceFeed } from "./interfaces/ILayerZeroPriceFeed.sol";
+import { IExecutor } from "./interfaces/IExecutor.sol";
+import { IExecutorFeeLib } from "./interfaces/IExecutorFeeLib.sol";
+import { ExecutorOptions } from "./libs/ExecutorOptions.sol";
+
+contract ExecutorFeeLib is Ownable, IExecutorFeeLib {
+    using ExecutorOptions for bytes;
+
+    uint256 private immutable nativeDecimalsRate;
+    uint32 private immutable localEidV2; // endpoint-v2 only, for read call
+
+    constructor(uint32 _localEidV2, uint256 _nativeDecimalsRate) {
+        localEidV2 = _localEidV2;
+        nativeDecimalsRate = _nativeDecimalsRate;
+    }
+
+    // ================================ OnlyOwner ================================
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyOwner {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+    }
+
+    // ================================ External ================================
+    function getFeeOnSend(
+        FeeParams calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 fee) {
+        fee = getFee(_params, _dstConfig, _options);
+    }
+
+    function getFeeOnSend(
+        FeeParamsForRead calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 fee) {
+        fee = getFee(_params, _dstConfig, _options);
+    }
+
+    // ================================ View ================================
+    function getFee(
+        FeeParams calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) public view returns (uint256 fee) {
+        if (_dstConfig.lzReceiveBaseGas == 0) revert Executor_EidNotSupported(_params.dstEid);
+
+        (uint256 totalValue, uint256 totalGas, ) = _decodeExecutorOptions(
+            false,
+            _isV1Eid(_params.dstEid),
+            _dstConfig.lzReceiveBaseGas,
+            _dstConfig.lzComposeBaseGas,
+            _dstConfig.nativeCap,
+            _options
+        );
+
+        (
+            uint256 totalGasFee,
+            uint128 priceRatio,
+            uint128 priceRatioDenominator,
+            uint128 nativePriceUSD
+        ) = ILayerZeroPriceFeed(_params.priceFeed).estimateFeeByEid(_params.dstEid, _params.calldataSize, totalGas);
+
+        uint16 multiplierBps = _dstConfig.multiplierBps == 0 ? _params.defaultMultiplierBps : _dstConfig.multiplierBps;
+
+        fee = _applyPremiumToGas(totalGasFee, multiplierBps, _dstConfig.floorMarginUSD, nativePriceUSD);
+        fee += _convertAndApplyPremiumToValue(totalValue, priceRatio, priceRatioDenominator, multiplierBps);
+    }
+
+    function getFee(
+        FeeParamsForRead calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) public view returns (uint256 fee) {
+        if (_dstConfig.lzReceiveBaseGas == 0) revert Executor_EidNotSupported(localEidV2);
+
+        (uint256 totalValue, uint256 totalGas, uint32 calldataSize) = _decodeExecutorOptions(
+            true,
+            false, // endpoint v2 only
+            _dstConfig.lzReceiveBaseGas,
+            _dstConfig.lzComposeBaseGas,
+            _dstConfig.nativeCap,
+            _options
+        );
+
+        (
+            uint256 totalGasFee,
+            uint128 priceRatio,
+            uint128 priceRatioDenominator,
+            uint128 nativePriceUSD
+        ) = ILayerZeroPriceFeed(_params.priceFeed).estimateFeeByEid(localEidV2, calldataSize, totalGas);
+
+        uint16 multiplierBps = _dstConfig.multiplierBps == 0 ? _params.defaultMultiplierBps : _dstConfig.multiplierBps;
+
+        fee = _applyPremiumToGas(totalGasFee, multiplierBps, _dstConfig.floorMarginUSD, nativePriceUSD);
+        fee += _convertAndApplyPremiumToValue(totalValue, priceRatio, priceRatioDenominator, multiplierBps);
+    }
+
+    // ================================ Internal ================================
+    // @dev decode executor options into dstAmount and totalGas
+    function _decodeExecutorOptions(
+        bool _isRead,
+        bool _v1Eid,
+        uint64 _lzReceiveBaseGas,
+        uint64 _lzComposeBaseGas,
+        uint128 _nativeCap,
+        bytes calldata _options
+    ) internal pure returns (uint256 totalValue, uint256 totalGas, uint32 calldataSize) {
+        ExecutorOptionsAgg memory aggOptions = _parseExecutorOptions(_options, _isRead, _v1Eid, _nativeCap);
+        totalValue = aggOptions.totalValue;
+        calldataSize = aggOptions.calldataSize;
+
+        // lz receive only called once
+        // lz compose can be called multiple times, based on unique index
+        // to simplify the quoting, we add lzComposeBaseGas for each lzComposeOption received
+        // if the same index has multiple compose options, the gas will be added multiple times
+        totalGas = _lzReceiveBaseGas + aggOptions.totalGas + _lzComposeBaseGas * aggOptions.numLzCompose;
+        if (aggOptions.ordered) {
+            totalGas = (totalGas * 102) / 100;
+        }
+    }
+
+    struct ExecutorOptionsAgg {
+        uint256 totalValue;
+        uint256 totalGas;
+        bool ordered;
+        uint32 calldataSize;
+        uint256 numLzCompose;
+    }
+
+    function _parseExecutorOptions(
+        bytes calldata _options,
+        bool _isRead,
+        bool _v1Eid,
+        uint128 _nativeCap
+    ) internal pure returns (ExecutorOptionsAgg memory options) {
+        if (_options.length == 0) {
+            revert Executor_NoOptions();
+        }
+
+        uint256 cursor = 0;
+        uint256 lzReceiveGas;
+        uint32 calldataSize;
+        while (cursor < _options.length) {
+            (uint8 optionType, bytes calldata option, uint256 newCursor) = _options.nextExecutorOption(cursor);
+            cursor = newCursor;
+
+            if (optionType == ExecutorOptions.OPTION_TYPE_LZRECEIVE) {
+                // lzRead does not support lzReceive option
+                if (_isRead) revert Executor_UnsupportedOptionType(optionType);
+                (uint128 gas, uint128 value) = ExecutorOptions.decodeLzReceiveOption(option);
+
+                // endpoint v1 does not support lzReceive with value
+                if (_v1Eid && value > 0) revert Executor_UnsupportedOptionType(optionType);
+
+                options.totalValue += value;
+                lzReceiveGas += gas;
+            } else if (optionType == ExecutorOptions.OPTION_TYPE_NATIVE_DROP) {
+                // lzRead does not support nativeDrop option
+                if (_isRead) revert Executor_UnsupportedOptionType(optionType);
+
+                (uint128 nativeDropAmount, ) = ExecutorOptions.decodeNativeDropOption(option);
+                options.totalValue += nativeDropAmount;
+            } else if (optionType == ExecutorOptions.OPTION_TYPE_LZCOMPOSE) {
+                // endpoint v1 does not support lzCompose
+                if (_v1Eid) revert Executor_UnsupportedOptionType(optionType);
+
+                (, uint128 gas, uint128 value) = ExecutorOptions.decodeLzComposeOption(option);
+                if (gas == 0) revert Executor_ZeroLzComposeGasProvided();
+
+                options.totalValue += value;
+                options.totalGas += gas;
+                options.numLzCompose++;
+            } else if (optionType == ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION) {
+                options.ordered = true;
+            } else if (optionType == ExecutorOptions.OPTION_TYPE_LZREAD) {
+                if (!_isRead) revert Executor_UnsupportedOptionType(optionType);
+
+                (uint128 gas, uint32 size, uint128 value) = ExecutorOptions.decodeLzReadOption(option);
+                options.totalValue += value;
+                lzReceiveGas += gas;
+                calldataSize += size;
+            } else {
+                revert Executor_UnsupportedOptionType(optionType);
+            }
+        }
+        if (cursor != _options.length) revert Executor_InvalidExecutorOptions(cursor);
+        if (options.totalValue > _nativeCap) revert Executor_NativeAmountExceedsCap(options.totalValue, _nativeCap);
+        if (lzReceiveGas == 0) revert Executor_ZeroLzReceiveGasProvided();
+        if (_isRead && calldataSize == 0) revert Executor_ZeroCalldataSizeProvided();
+        options.totalGas += lzReceiveGas;
+        options.calldataSize = calldataSize;
+    }
+
+    function _applyPremiumToGas(
+        uint256 _fee,
+        uint16 _multiplierBps,
+        uint128 _marginUSD,
+        uint128 _nativePriceUSD
+    ) internal view returns (uint256) {
+        uint256 feeWithMultiplier = (_fee * _multiplierBps) / 10000;
+
+        if (_nativePriceUSD == 0 || _marginUSD == 0) {
+            return feeWithMultiplier;
+        }
+        uint256 feeWithMargin = (_marginUSD * nativeDecimalsRate) / _nativePriceUSD + _fee;
+        return feeWithMargin > feeWithMultiplier ? feeWithMargin : feeWithMultiplier;
+    }
+
+    // includes value and nativeDrop
+    function _convertAndApplyPremiumToValue(
+        uint256 _value,
+        uint128 _ratio,
+        uint128 _denom,
+        uint16 _multiplierBps
+    ) internal pure returns (uint256 fee) {
+        if (_value > 0) {
+            fee = (((_value * _ratio) / _denom) * _multiplierBps) / 10000;
+        }
+    }
+
+    function _isV1Eid(uint32 _eid) internal pure virtual returns (bool) {
+        // v1 eid is < 30000
+        return _eid < 30000;
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor) {
+        return (1, 1);
+    }
+
+    // send funds here to pay for price feed directly
+    receive() external payable {}
+}

package/contracts/MessageLibBase.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+/// @dev simply a container of endpoint address and local eid
+abstract contract MessageLibBase {
+    address internal immutable endpoint;
+    uint32 internal immutable localEid;
+
+    error LZ_MessageLib_OnlyEndpoint();
+
+    modifier onlyEndpoint() {
+        if (endpoint != msg.sender) revert LZ_MessageLib_OnlyEndpoint();
+        _;
+    }
+
+    constructor(address _endpoint, uint32 _localEid) {
+        endpoint = _endpoint;
+        localEid = _localEid;
+    }
+}