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

package/contracts/decompressor/DecompressorExtension.sol

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title DecompressorExtension
+ * @dev A contract that implements a decompression algorithm to be used in conjunction with compressed data.
+ * You should implement in your contract a function that makes use of the internal methods `_setData`, `_setDataArray` for data addition to the dictionary.
+ * NOTE: It is important to implement a delay when using the `_setData` and `_setDataArray` methods in your transactions. This delay helps to guard against the possibility of frontrunning, which can occur when the state of the dictionary changes during the execution of a transaction.
+ * @notice This extension could result in a much higher gas consumption than expected and could potentially lead to significant memory expansion costs. Be sure to properly estimate these aspects to avoid unforeseen expenses.
+ */
+abstract contract DecompressorExtension {
+    /**
+     * @dev Emitted when an offset is used incorrectly, either because it is too small, or because its sum with a dict data's length exceeds a certain limit.
+     * @param value The incorrect value used as an offset or as the sum of the offset and a dict data's length.
+     */
+    error IncorrectDictAccess(uint256 value);
+
+    uint256 public constant MAX_DICT_LEN = 1_048_576; // 2 ** 20
+    uint256 public constant RESERVE_DICT_LEN = 2; // 0: msg.sender; 1: address(this)
+
+    /**
+     * @dev The dictionary mapping storage slots to their associated compressed data.
+     */
+    bytes32[MAX_DICT_LEN] private _dict;
+
+    /**
+     * @dev Ensures the provided value is correctly used as an offset. This includes checks for the offset being too small or its sum with an dict data's length exceeding a certain limit. Value less `RESERVE_DICT_LEN` are reserved.
+     * @param value The value used as an offset or as the sum of the offset and an array's length.
+     */
+    modifier validDictAccess(uint256 value) {
+        if (value < RESERVE_DICT_LEN || value >= MAX_DICT_LEN) revert IncorrectDictAccess(value);
+        _;
+    }
+
+    /**
+     * @dev Returns the data stored in the dictionary in the specified range.
+     * @param begin The starting index of the data range to return. First 2 positions are reserved, so it should be greater than 1.
+     * @param end The ending index of the data range to return.
+     * @return res An array of bytes32 values containing the data in the specified range.
+     */
+    function getData(
+        uint256 begin,
+        uint256 end
+    ) external view validDictAccess(begin) validDictAccess(end) returns (bytes32[] memory res) {
+        unchecked {
+            if (begin < end) {
+                res = new bytes32[](end - begin);
+                for (uint256 i = begin; i < end; i++) {
+                    res[i - begin] = _dict[i];
+                }
+            }
+        }
+    }
+
+    /**
+     * @dev Sets the data at the specified dictionary offset.
+     * @param offset The dictionary offset to set the data at. First 2 positions are reserved, so it should be greater than 1.
+     * @param data The data to be stored at the specified offset.
+     */
+    function _setData(uint256 offset, bytes32 data) internal validDictAccess(offset) {
+        unchecked {
+            _dict[offset] = data;
+        }
+    }
+
+    /**
+     * @dev Sets an array of data starting at the specified dictionary offset.
+     * @param offset The starting dictionary offset to set the data at. First 2 positions are reserved, so it should be greater than 1.
+     * @param dataArray The array of data to be stored starting at the specified offset.
+     */
+    function _setDataArray(
+        uint256 offset,
+        bytes32[] calldata dataArray
+    ) internal validDictAccess(offset) validDictAccess(offset + dataArray.length) {
+        unchecked {
+            for (uint256 i = 0; i < dataArray.length; i++) {
+                _dict[offset + i] = dataArray[i];
+            }
+        }
+    }
+
+    /**
+     * @dev Decompresses the compressed data (N bytes) passed to the function using the _delegatecall function.
+     */
+    function decompress() external payable {
+        _delegatecall(decompressed());
+    }
+
+    /**
+     * @dev Calculates and returns the decompressed data from the compressed calldata.
+     * @return raw The decompressed raw data.
+     */
+    function decompressed() public view returns (bytes memory raw) {
+        return _decompressed(msg.data[4:]);
+    }
+
+    /**
+     * @dev Calculates and returns the decompressed raw data from the compressed data passed as an argument.
+     * @param cd The compressed data to be decompressed.
+     * @return raw The decompressed raw data.
+     */
+    function _decompressed(bytes calldata cd) internal view returns (bytes memory raw) {
+        assembly ("memory-safe") {
+            // solhint-disable-line no-inline-assembly
+            raw := mload(0x40)
+            let outptr := add(raw, 0x20)
+            let end := add(cd.offset, cd.length)
+            for {
+                let inptr := cd.offset
+            } lt(inptr, end) {
+
+            } {
+                // solhint-disable-line no-empty-blocks
+                let data := calldataload(inptr)
+
+                let key
+
+                // 00XXXXXX - insert X+1 zero bytes
+                // 01PXXXXX - copy X+1 bytes calldata (P means padding to 32 bytes or not)
+                // 10BBXXXX XXXXXXXX - use 12 bits as key for [32,20,4,31][B] bytes from storage X
+                // 11BBXXXX XXXXXXXX XXXXXXXX - use 20 bits as [32,20,4,31][B] bytes from storage X
+                switch shr(254, data)
+                case 0 {
+                    let size := add(byte(0, data), 1)
+                    calldatacopy(outptr, calldatasize(), size)
+                    inptr := add(inptr, 1)
+                    outptr := add(outptr, size)
+                    continue
+                }
+                case 1 {
+                    let size := add(and(0x1F, byte(0, data)), 1)
+                    if and(data, 0x2000000000000000000000000000000000000000000000000000000000000000) {
+                        mstore(outptr, 0)
+                        outptr := add(outptr, sub(32, size))
+                    }
+                    calldatacopy(outptr, add(inptr, 1), size)
+                    inptr := add(inptr, add(1, size))
+                    outptr := add(outptr, size)
+                    continue
+                }
+                case 2 {
+                    key := shr(244, shl(4, data))
+                    inptr := add(inptr, 2)
+                    // fallthrough
+                }
+                case 3 {
+                    key := shr(236, shl(4, data))
+                    inptr := add(inptr, 3)
+                    // fallthrough
+                }
+
+                // TODO: check sload argument
+                let value
+                switch key
+                case 0 {
+                    value := caller()
+                }
+                case 1 {
+                    value := address()
+                }
+                default {
+                    value := sload(add(_dict.slot, key))
+                }
+
+                switch shr(254, shl(2, data))
+                case 0 {
+                    mstore(outptr, value)
+                    outptr := add(outptr, 32)
+                }
+                case 1 {
+                    mstore(outptr, shl(96, value))
+                    outptr := add(outptr, 20)
+                }
+                case 2 {
+                    mstore(outptr, shl(224, value))
+                    outptr := add(outptr, 4)
+                }
+                default {
+                    mstore(outptr, shl(8, value))
+                    outptr := add(outptr, 31)
+                }
+            }
+            mstore(raw, sub(sub(outptr, raw), 0x20))
+            mstore(0x40, outptr)
+        }
+    }
+
+    /**
+     * @dev Executes a delegate call to the raw data calculated by the _decompressed function.
+     * @param raw The raw data to execute the delegate call with.
+     */
+    function _delegatecall(bytes memory raw) internal {
+        assembly ("memory-safe") {
+            // solhint-disable-line no-inline-assembly
+            let success := delegatecall(gas(), address(), add(raw, 0x20), mload(raw), 0, 0)
+            returndatacopy(0, 0, returndatasize())
+            if success {
+                return(0, returndatasize())
+            }
+            revert(0, returndatasize())
+        }
+    }
+}

package/contracts/decompressor/ExecutorDecoder.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { IExecutor } from "../interfaces/IExecutor.sol";
+
+library ExecutorDecoder {
+    uint8 internal constant NATIVE_DROP_GAS_LIMIT_OFFSET = 0; // uint32
+    uint8 internal constant SRC_EID_OFFSET = 4; // uint32
+    uint8 internal constant SENDER_OFFSET = 8; // bytes32
+    uint8 internal constant NONCE_OFFSET = 40; // uint64
+    uint8 internal constant RECEIVER_OFFSET = 48; // address
+
+    uint8 internal constant NATIVEDROP_DST_EID_OFFSET = 68; // uint32
+    uint8 internal constant DST_EID_SIZE = 4; // uint32
+    function nativeDrop(
+        bytes calldata _encoded
+    )
+        internal
+        pure
+        returns (
+            Origin memory origin,
+            uint32 dstEid,
+            address receiver,
+            IExecutor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit
+        )
+    {
+        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));
+        origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));
+        origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);
+        origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:RECEIVER_OFFSET]));
+        receiver = address(bytes20(_encoded[RECEIVER_OFFSET:NATIVEDROP_DST_EID_OFFSET]));
+
+        uint8 nativeDropOffset = NATIVEDROP_DST_EID_OFFSET + DST_EID_SIZE;
+        dstEid = uint32(bytes4(_encoded[NATIVEDROP_DST_EID_OFFSET:nativeDropOffset]));
+
+        nativeDropParams = _nativeDrop(_encoded[nativeDropOffset:]);
+    }
+
+    uint8 internal constant EXECUTE301_GAS_LIMIT_OFFSET = 0; // uint64
+    uint8 internal constant EXECUTE301_PACKET_OFFSET = 8; // uint64
+    function execute301(bytes calldata encoded) internal pure returns (bytes memory packet, uint256 gasLimit) {
+        gasLimit = uint256(uint64(bytes8(encoded[EXECUTE301_GAS_LIMIT_OFFSET:EXECUTE301_PACKET_OFFSET])));
+        packet = encoded[EXECUTE301_PACKET_OFFSET:];
+    }
+
+    uint8 internal constant NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET = 48; // uint64
+    uint8 internal constant NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET = 56; // uint64
+    uint8 internal constant NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET = 64; // uint64
+    function nativeDropAndExecute301(
+        bytes calldata _encoded
+    )
+        internal
+        pure
+        returns (
+            Origin memory origin,
+            IExecutor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit,
+            bytes memory packet,
+            uint256 gasLimit
+        )
+    {
+        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));
+        origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));
+        origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);
+        origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET]));
+
+        gasLimit = uint256(
+            uint64(
+                bytes8(
+                    _encoded[NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET:NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET]
+                )
+            )
+        );
+
+        uint64 packetLength = uint64(
+            bytes8(_encoded[NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET:NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET])
+        );
+
+        uint256 cursor = NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET;
+
+        packet = _encoded[cursor:cursor + packetLength];
+        cursor += packetLength;
+
+        nativeDropParams = _nativeDrop(_encoded[cursor:]);
+    }
+
+    uint8 internal constant EXECUTE302_GUID_OFFSET = 68; // bytes32
+    uint8 internal constant EXECUTE302_GAS_LIMIT_OFFSET = 100; // uint64
+    uint8 internal constant EXECUTE302_MESSAGE_LENGTH_OFFSET = 108; // uint64
+    uint8 internal constant EXECUTE302_MESSAGE_OFFSET = 116; // uint64
+    uint8 internal constant EXTRA_DATA_LENGTH_SIZE = 8; // uint64
+    function nativeDropAndExecute302(
+        bytes calldata _encoded
+    )
+        internal
+        pure
+        returns (
+            IExecutor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit,
+            IExecutor.ExecutionParams memory executionParams
+        )
+    {
+        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));
+        executionParams.origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));
+        executionParams.origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);
+        executionParams.origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:RECEIVER_OFFSET]));
+        executionParams.receiver = address(bytes20(_encoded[RECEIVER_OFFSET:EXECUTE302_GUID_OFFSET]));
+        executionParams.guid = bytes32(_encoded[EXECUTE302_GUID_OFFSET:EXECUTE302_GAS_LIMIT_OFFSET]);
+        executionParams.gasLimit = uint256(
+            uint64(bytes8(_encoded[EXECUTE302_GAS_LIMIT_OFFSET:EXECUTE302_MESSAGE_LENGTH_OFFSET]))
+        );
+
+        uint64 messageLength = uint64(bytes8(_encoded[EXECUTE302_MESSAGE_LENGTH_OFFSET:EXECUTE302_MESSAGE_OFFSET]));
+        uint256 cursor = EXECUTE302_MESSAGE_OFFSET;
+
+        executionParams.message = _encoded[cursor:cursor + messageLength];
+        cursor += messageLength;
+
+        uint64 extraDataLength = uint64(bytes8(_encoded[cursor:cursor + EXTRA_DATA_LENGTH_SIZE]));
+        cursor += EXTRA_DATA_LENGTH_SIZE;
+
+        executionParams.extraData = _encoded[cursor:cursor + extraDataLength];
+        cursor += extraDataLength;
+
+        nativeDropParams = _nativeDrop(_encoded[cursor:]);
+    }
+
+    uint8 internal constant NATIVE_DROP_RECEIVER_SIZE = 20; // address
+    uint8 internal constant NATIVE_DROP_AMOUNT_SIZE = 9; // uint72
+    uint8 internal constant NATIVE_DROP_PARAM_SIZE = 29; // 20 + 9
+    function _nativeDrop(
+        bytes calldata _encoded
+    ) internal pure returns (IExecutor.NativeDropParams[] memory nativeDropParams) {
+        uint256 cursor = 0;
+        uint256 nativeDropParamsLength = _encoded.length / NATIVE_DROP_PARAM_SIZE;
+
+        nativeDropParams = new IExecutor.NativeDropParams[](nativeDropParamsLength);
+        for (uint256 i = 0; i < nativeDropParamsLength; i++) {
+            nativeDropParams[i].receiver = address(bytes20(_encoded[cursor:cursor + NATIVE_DROP_RECEIVER_SIZE]));
+            cursor += NATIVE_DROP_RECEIVER_SIZE;
+            nativeDropParams[i].amount = uint256(uint72(bytes9(_encoded[cursor:cursor + NATIVE_DROP_AMOUNT_SIZE])));
+            cursor += NATIVE_DROP_AMOUNT_SIZE;
+        }
+    }
+}

package/contracts/decompressor/ExecutorDecompressor.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+import { Executor } from "../Executor.sol";
+import { ExecutorDecoder } from "./ExecutorDecoder.sol";
+import { DecompressorExtension } from "./DecompressorExtension.sol";
+
+contract ExecutorDecompressor is Ownable, DecompressorExtension {
+    Executor public immutable executor;
+
+    constructor(Executor _executor) {
+        executor = _executor;
+    }
+
+    function nativeDrop(bytes calldata _encoded) external onlyOwner {
+        (
+            Origin memory origin,
+            uint32 dstEid,
+            address oapp,
+            Executor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit
+        ) = ExecutorDecoder.nativeDrop(_encoded);
+
+        executor.nativeDrop(origin, dstEid, oapp, nativeDropParams, nativeDropGasLimit);
+    }
+
+    function execute301(bytes calldata _encoded) external onlyOwner {
+        (bytes memory packet, uint256 gasLimit) = ExecutorDecoder.execute301(_encoded);
+
+        executor.execute301(packet, gasLimit);
+    }
+
+    function nativeDropAndExecute301(bytes calldata _encoded) external onlyOwner {
+        (
+            Origin memory origin,
+            Executor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit,
+            bytes memory packet,
+            uint256 gasLimit
+        ) = ExecutorDecoder.nativeDropAndExecute301(_encoded);
+
+        executor.nativeDropAndExecute301(origin, nativeDropParams, nativeDropGasLimit, packet, gasLimit);
+    }
+
+    function nativeDropAndExecute302(bytes calldata _encoded) external onlyOwner {
+        (
+            Executor.NativeDropParams[] memory nativeDropParams,
+            uint256 nativeDropGasLimit,
+            Executor.ExecutionParams memory executionParams
+        ) = ExecutorDecoder.nativeDropAndExecute302(_encoded);
+
+        executor.nativeDropAndExecute302(nativeDropParams, nativeDropGasLimit, executionParams);
+    }
+}

package/contracts/interfaces/IExecutor.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+import { IWorker } from "./IWorker.sol";
+import { ILayerZeroExecutor } from "./ILayerZeroExecutor.sol";
+import { ILayerZeroReadExecutor } from "./ILayerZeroReadExecutor.sol";
+
+interface IExecutor is IWorker, ILayerZeroExecutor, ILayerZeroReadExecutor {
+    struct DstConfigParam {
+        uint32 dstEid;
+        uint64 lzReceiveBaseGas;
+        uint64 lzComposeBaseGas;
+        uint16 multiplierBps;
+        uint128 floorMarginUSD;
+        uint128 nativeCap;
+    }
+
+    struct DstConfig {
+        uint64 lzReceiveBaseGas;
+        uint16 multiplierBps;
+        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR
+        uint128 nativeCap;
+        uint64 lzComposeBaseGas;
+    }
+
+    struct ExecutionParams {
+        address receiver;
+        Origin origin;
+        bytes32 guid;
+        bytes message;
+        bytes extraData;
+        uint256 gasLimit;
+    }
+
+    struct NativeDropParams {
+        address receiver;
+        uint256 amount;
+    }
+
+    event DstConfigSet(DstConfigParam[] params);
+    event NativeDropApplied(Origin origin, uint32 dstEid, address oapp, NativeDropParams[] params, bool[] success);
+
+    function dstConfig(uint32 _dstEid) external view returns (uint64, uint16, uint128, uint128, uint64);
+}

package/contracts/interfaces/IExecutorFeeLib.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IExecutor } from "./IExecutor.sol";
+
+interface IExecutorFeeLib {
+    struct FeeParams {
+        address priceFeed;
+        uint32 dstEid;
+        address sender;
+        uint256 calldataSize;
+        uint16 defaultMultiplierBps;
+    }
+
+    struct FeeParamsForRead {
+        address priceFeed;
+        address sender;
+        uint16 defaultMultiplierBps;
+    }
+
+    error Executor_NoOptions();
+    error Executor_NativeAmountExceedsCap(uint256 amount, uint256 cap);
+    error Executor_UnsupportedOptionType(uint8 optionType);
+    error Executor_InvalidExecutorOptions(uint256 cursor);
+    error Executor_ZeroLzReceiveGasProvided();
+    error Executor_ZeroLzComposeGasProvided();
+    error Executor_ZeroCalldataSizeProvided();
+    error Executor_EidNotSupported(uint32 eid);
+
+    function getFeeOnSend(
+        FeeParams calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external returns (uint256 fee);
+
+    function getFee(
+        FeeParams calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+
+    function getFeeOnSend(
+        FeeParamsForRead calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external returns (uint256 fee);
+
+    function getFee(
+        FeeParamsForRead calldata _params,
+        IExecutor.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external view returns (uint256 fee);
+
+    function version() external view returns (uint64 major, uint8 minor);
+}

package/contracts/interfaces/ILayerZeroExecutor.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroExecutor {
+    // @notice query price and assign jobs at the same time
+    // @param _dstEid - the destination endpoint identifier
+    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
+    // @param _calldataSize - dynamic data size of message + caller params
+    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain
+    function assignJob(
+        uint32 _dstEid,
+        address _sender,
+        uint256 _calldataSize,
+        bytes calldata _options
+    ) external returns (uint256 price);
+
+    // @notice query the executor price for relaying the payload and its proof to the destination chain
+    // @param _dstEid - the destination endpoint identifier
+    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
+    // @param _calldataSize - dynamic data size of message + caller params
+    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain
+    function getFee(
+        uint32 _dstEid,
+        address _sender,
+        uint256 _calldataSize,
+        bytes calldata _options
+    ) external view returns (uint256 price);
+}

package/contracts/interfaces/ILayerZeroPriceFeed.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroPriceFeed {
+    /**
+     * @dev
+     * priceRatio: (USD price of 1 unit of remote native token in unit of local native token) * PRICE_RATIO_DENOMINATOR
+     */
+
+    struct Price {
+        uint128 priceRatio; // float value * 10 ^ 20, decimal awared. for aptos to evm, the basis would be (10^18 / 10^8) * 10 ^20 = 10 ^ 30.
+        uint64 gasPriceInUnit; // for evm, it is in wei, for aptos, it is in octas.
+        uint32 gasPerByte;
+    }
+
+    struct UpdatePrice {
+        uint32 eid;
+        Price price;
+    }
+
+    /**
+     * @dev
+     *    ArbGasInfo.go:GetPricesInArbGas
+     *
+     */
+    struct ArbitrumPriceExt {
+        uint64 gasPerL2Tx; // L2 overhead
+        uint32 gasPerL1CallDataByte;
+    }
+
+    struct UpdatePriceExt {
+        uint32 eid;
+        Price price;
+        ArbitrumPriceExt extend;
+    }
+
+    error LZ_PriceFeed_OnlyPriceUpdater();
+    error LZ_PriceFeed_InsufficientFee(uint256 provided, uint256 required);
+    error LZ_PriceFeed_NotAnOPStack(uint32 l2Eid);
+
+    function nativeTokenPriceUSD() external view returns (uint128);
+
+    function getFee(uint32 _dstEid, uint256 _callDataSize, uint256 _gas) external view returns (uint256);
+
+    function getPrice(uint32 _dstEid) external view returns (Price memory);
+
+    function getPriceRatioDenominator() external view returns (uint128);
+
+    function estimateFeeByEid(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) external view returns (uint256 fee, uint128 priceRatio, uint128 priceRatioDenominator, uint128 nativePriceUSD);
+
+    function estimateFeeOnSend(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) external payable returns (uint256 fee, uint128 priceRatio, uint128 priceRatioDenominator, uint128 nativePriceUSD);
+}

package/contracts/interfaces/ILayerZeroReadExecutor.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroReadExecutor {
+    // @notice query price and assign jobs at the same time
+    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
+    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain
+    function assignJob(address _sender, bytes calldata _options) external returns (uint256 fee);
+
+    // @notice query the executor price for executing the payload on this chain
+    // @param _sender - the source sending contract address. executors may apply price discrimination to senders
+    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens
+    function getFee(address _sender, bytes calldata _options) external view returns (uint256 fee);
+}

package/contracts/interfaces/ILayerZeroTreasury.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface ILayerZeroTreasury {
+    function getFee(
+        address _sender,
+        uint32 _dstEid,
+        uint256 _totalNativeFee,
+        bool _payInLzToken
+    ) external view returns (uint256 fee);
+
+    function payFee(
+        address _sender,
+        uint32 _dstEid,
+        uint256 _totalNativeFee,
+        bool _payInLzToken
+    ) external payable returns (uint256 fee);
+}

package/contracts/interfaces/IWorker.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IWorker {
+    event SetWorkerLib(address workerLib);
+    event SetPriceFeed(address priceFeed);
+    event SetDefaultMultiplierBps(uint16 multiplierBps);
+    event SetSupportedOptionTypes(uint32 dstEid, uint8[] optionTypes);
+    event Withdraw(address lib, address to, uint256 amount);
+
+    error Worker_NotAllowed();
+    error Worker_OnlyMessageLib();
+    error Worker_RoleRenouncingDisabled();
+
+    function setPriceFeed(address _priceFeed) external;
+
+    function priceFeed() external view returns (address);
+
+    function setDefaultMultiplierBps(uint16 _multiplierBps) external;
+
+    function defaultMultiplierBps() external view returns (uint16);
+
+    function withdrawFee(address _lib, address _to, uint256 _amount) external;
+
+    function setSupportedOptionTypes(uint32 _eid, uint8[] calldata _optionTypes) external;
+
+    function getSupportedOptionTypes(uint32 _eid) external view returns (uint8[] memory);
+}