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

package/contracts/PriceFeed.sol

@@ -0,0 +1,304 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { Proxied } from "hardhat-deploy/solc_0.8/proxy/Proxied.sol";
+
+import { ILayerZeroEndpointV2 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { ILayerZeroPriceFeed } from "./interfaces/ILayerZeroPriceFeed.sol";
+
+enum ModelType {
+    DEFAULT,
+    ARB_STACK,
+    OP_STACK
+}
+
+struct SetEidToModelTypeParam {
+    uint32 dstEid;
+    ModelType modelType;
+}
+
+// PriceFeed is updated based on v1 eids
+// v2 eids will fall to the convention of v1 eid + 30,000
+contract PriceFeed is ILayerZeroPriceFeed, OwnableUpgradeable, Proxied {
+    uint128 internal PRICE_RATIO_DENOMINATOR;
+
+    // sets pricing
+    mapping(address updater => bool active) public priceUpdater;
+
+    mapping(uint32 dstEid => Price) internal _defaultModelPrice;
+    ArbitrumPriceExt internal _arbitrumPriceExt;
+
+    uint128 internal _nativePriceUSD; // uses PRICE_RATIO_DENOMINATOR
+
+    // upgrade: arbitrum compression - percentage of callDataSize after brotli compression
+    uint128 public ARBITRUM_COMPRESSION_PERCENT;
+
+    ILayerZeroEndpointV2 public endpoint;
+
+    // for the destination endpoint id, return the fee model type
+    mapping(uint32 => ModelType) public eidToModelType;
+
+    // ============================ Constructor ===================================
+
+    function initialize(address _priceUpdater) public proxied initializer {
+        __Ownable_init();
+        priceUpdater[_priceUpdater] = true;
+        PRICE_RATIO_DENOMINATOR = 1e20;
+        ARBITRUM_COMPRESSION_PERCENT = 47;
+    }
+
+    // ============================ Modifier ======================================
+
+    // owner is always approved
+    modifier onlyPriceUpdater() {
+        if (owner() != msg.sender) {
+            if (!priceUpdater[msg.sender]) {
+                revert LZ_PriceFeed_OnlyPriceUpdater();
+            }
+        }
+        _;
+    }
+
+    // ============================ OnlyOwner =====================================
+
+    function setPriceUpdater(address _addr, bool _active) external onlyOwner {
+        priceUpdater[_addr] = _active;
+    }
+
+    function setPriceRatioDenominator(uint128 _denominator) external onlyOwner {
+        PRICE_RATIO_DENOMINATOR = _denominator;
+    }
+
+    function setArbitrumCompressionPercent(uint128 _compressionPercent) external onlyOwner {
+        ARBITRUM_COMPRESSION_PERCENT = _compressionPercent;
+    }
+
+    // set the fee ModelType for the destination eid
+    function setEidToModelType(SetEidToModelTypeParam[] calldata _params) external onlyOwner {
+        for (uint i = 0; i < _params.length; i++) {
+            eidToModelType[_params[i].dstEid] = _params[i].modelType;
+        }
+    }
+
+    function setEndpoint(address _endpoint) external onlyOwner {
+        endpoint = ILayerZeroEndpointV2(_endpoint);
+    }
+
+    function withdrawFee(address _to, uint256 _amount) external onlyOwner {
+        Transfer.native(_to, _amount);
+    }
+
+    // ============================ OnlyPriceUpdater =====================================
+
+    function setPrice(UpdatePrice[] calldata _price) external onlyPriceUpdater {
+        for (uint256 i = 0; i < _price.length; i++) {
+            UpdatePrice calldata _update = _price[i];
+            _setPrice(_update.eid, _update.price);
+        }
+    }
+
+    function setPriceForArbitrum(UpdatePriceExt calldata _update) external onlyPriceUpdater {
+        _setPrice(_update.eid, _update.price);
+
+        uint64 gasPerL2Tx = _update.extend.gasPerL2Tx;
+        uint32 gasPerL1CalldataByte = _update.extend.gasPerL1CallDataByte;
+
+        _arbitrumPriceExt.gasPerL2Tx = gasPerL2Tx;
+        _arbitrumPriceExt.gasPerL1CallDataByte = gasPerL1CalldataByte;
+    }
+
+    function setNativeTokenPriceUSD(uint128 _nativeTokenPriceUSD) external onlyPriceUpdater {
+        _nativePriceUSD = _nativeTokenPriceUSD;
+    }
+
+    // ============================ External =====================================
+
+    function estimateFeeOnSend(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) external payable returns (uint256, uint128, uint128, uint128) {
+        uint256 fee = getFee(_dstEid, _callDataSize, _gas);
+        if (msg.value < fee) revert LZ_PriceFeed_InsufficientFee(msg.value, fee);
+        return _estimateFeeByEid(_dstEid, _callDataSize, _gas);
+    }
+
+    // ============================ View ==========================================
+
+    // get fee for calling estimateFeeOnSend
+    function getFee(uint32 /*_dstEid*/, uint256 /*_callDataSize*/, uint256 /*_gas*/) public pure returns (uint256) {
+        return 0;
+    }
+
+    function getPriceRatioDenominator() external view returns (uint128) {
+        return PRICE_RATIO_DENOMINATOR;
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    function nativeTokenPriceUSD() external view returns (uint128) {
+        return _nativePriceUSD;
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    function arbitrumPriceExt() external view returns (ArbitrumPriceExt memory) {
+        return _arbitrumPriceExt;
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    function getPrice(uint32 _dstEid) external view returns (Price memory price) {
+        price = _defaultModelPrice[_dstEid];
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    function estimateFeeByEid(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) external view returns (uint256, uint128, uint128, uint128) {
+        return _estimateFeeByEid(_dstEid, _callDataSize, _gas);
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    // NOTE: to support legacy
+    function getPrice(uint16 _dstEid) external view returns (Price memory price) {
+        price = _defaultModelPrice[_dstEid];
+    }
+
+    // NOTE: to be reverted when endpoint is in sendContext
+    // NOTE: to support legacy
+    function estimateFeeByChain(
+        uint16 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) external view returns (uint256 fee, uint128 priceRatio) {
+        // legacy if-statement uses very little gas, can keep using it until future upgrade
+        if (_dstEid == 110 || _dstEid == 10143 || _dstEid == 20143) {
+            return _estimateFeeWithArbitrumModel(_dstEid, _callDataSize, _gas);
+        } else if (_dstEid == 111 || _dstEid == 10132 || _dstEid == 20132) {
+            return _estimateFeeWithOptimismModel(_dstEid, _callDataSize, _gas);
+        }
+
+        // fee model type is configured per eid
+        ModelType _modelType = eidToModelType[_dstEid];
+        if (_modelType == ModelType.OP_STACK) {
+            return _estimateFeeWithOptimismModel(_dstEid, _callDataSize, _gas);
+        } else if (_modelType == ModelType.ARB_STACK) {
+            return _estimateFeeWithArbitrumModel(_dstEid, _callDataSize, _gas);
+        } else {
+            return _estimateFeeWithDefaultModel(_dstEid, _callDataSize, _gas);
+        }
+    }
+
+    // ============================ Internal ==========================================
+
+    function _setPrice(uint32 _dstEid, Price memory _price) internal {
+        uint128 priceRatio = _price.priceRatio;
+        uint64 gasPriceInUnit = _price.gasPriceInUnit;
+        uint32 gasPerByte = _price.gasPerByte;
+        _defaultModelPrice[_dstEid] = Price(priceRatio, gasPriceInUnit, gasPerByte);
+    }
+
+    function _getL1LookupIdForOptimismModel(uint32 _l2Eid) internal view returns (uint32) {
+        uint32 l2Eid = _l2Eid % 30_000;
+        if (l2Eid == 111) {
+            return 101;
+        } else if (l2Eid == 10132) {
+            return 10121; // ethereum-goerli
+        } else if (l2Eid == 20132) {
+            return 20121; // ethereum-goerli
+        }
+
+        if (eidToModelType[l2Eid] != ModelType.OP_STACK) revert LZ_PriceFeed_NotAnOPStack(_l2Eid);
+        if (l2Eid < 10000) {
+            return 101;
+        } else if (l2Eid < 20000) {
+            return 10161; // ethereum-sepolia
+        } else {
+            return 20121; // ethereum-goerli
+        }
+    }
+
+    function _estimateFeeWithDefaultModel(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) internal view returns (uint256 fee, uint128 priceRatio) {
+        Price storage remotePrice = _defaultModelPrice[_dstEid];
+
+        // assuming the _gas includes (1) the 21,000 overhead and (2) not the calldata gas
+        uint256 gasForCallData = _callDataSize * remotePrice.gasPerByte;
+        uint256 remoteFee = (gasForCallData + _gas) * remotePrice.gasPriceInUnit;
+        return ((remoteFee * remotePrice.priceRatio) / PRICE_RATIO_DENOMINATOR, remotePrice.priceRatio);
+    }
+
+    function _estimateFeeByEid(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) internal view returns (uint256 fee, uint128 priceRatio, uint128 priceRatioDenominator, uint128 priceUSD) {
+        uint32 dstEid = _dstEid % 30_000;
+        if (dstEid == 110 || dstEid == 10143 || dstEid == 20143) {
+            (fee, priceRatio) = _estimateFeeWithArbitrumModel(dstEid, _callDataSize, _gas);
+        } else if (dstEid == 111 || dstEid == 10132 || dstEid == 20132) {
+            (fee, priceRatio) = _estimateFeeWithOptimismModel(dstEid, _callDataSize, _gas);
+        }
+
+        // lookup map stuff
+        ModelType _modelType = eidToModelType[dstEid];
+        if (_modelType == ModelType.OP_STACK) {
+            (fee, priceRatio) = _estimateFeeWithOptimismModel(dstEid, _callDataSize, _gas);
+        } else if (_modelType == ModelType.ARB_STACK) {
+            (fee, priceRatio) = _estimateFeeWithArbitrumModel(dstEid, _callDataSize, _gas);
+        } else {
+            (fee, priceRatio) = _estimateFeeWithDefaultModel(dstEid, _callDataSize, _gas);
+        }
+
+        priceRatioDenominator = PRICE_RATIO_DENOMINATOR;
+        priceUSD = _nativePriceUSD;
+    }
+
+    function _estimateFeeWithOptimismModel(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) internal view returns (uint256 fee, uint128 priceRatio) {
+        uint32 ethereumId = _getL1LookupIdForOptimismModel(_dstEid);
+
+        // L1 fee
+        Price storage ethereumPrice = _defaultModelPrice[ethereumId];
+        uint256 gasForL1CallData = (_callDataSize * ethereumPrice.gasPerByte) + 3188; // 2100 + 68 * 16
+        uint256 l1Fee = gasForL1CallData * ethereumPrice.gasPriceInUnit;
+
+        // L2 fee
+        Price storage optimismPrice = _defaultModelPrice[_dstEid];
+        uint256 gasForL2CallData = _callDataSize * optimismPrice.gasPerByte;
+        uint256 l2Fee = (gasForL2CallData + _gas) * optimismPrice.gasPriceInUnit;
+
+        uint256 l1FeeInSrcPrice = (l1Fee * ethereumPrice.priceRatio) / PRICE_RATIO_DENOMINATOR;
+        uint256 l2FeeInSrcPrice = (l2Fee * optimismPrice.priceRatio) / PRICE_RATIO_DENOMINATOR;
+        uint256 gasFee = l1FeeInSrcPrice + l2FeeInSrcPrice;
+        return (gasFee, optimismPrice.priceRatio);
+    }
+
+    function _estimateFeeWithArbitrumModel(
+        uint32 _dstEid,
+        uint256 _callDataSize,
+        uint256 _gas
+    ) internal view returns (uint256 fee, uint128 priceRatio) {
+        Price storage arbitrumPrice = _defaultModelPrice[_dstEid];
+
+        // L1 fee
+        uint256 gasForL1CallData = ((_callDataSize * ARBITRUM_COMPRESSION_PERCENT) / 100) *
+            _arbitrumPriceExt.gasPerL1CallDataByte;
+        // L2 Fee
+        uint256 gasForL2CallData = _callDataSize * arbitrumPrice.gasPerByte;
+        uint256 gasFee = (_gas + _arbitrumPriceExt.gasPerL2Tx + gasForL1CallData + gasForL2CallData) *
+            arbitrumPrice.gasPriceInUnit;
+
+        return ((gasFee * arbitrumPrice.priceRatio) / PRICE_RATIO_DENOMINATOR, arbitrumPrice.priceRatio);
+    }
+}

package/contracts/ReceiveLibBaseE2.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+import { ILayerZeroEndpointV2, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { IMessageLib, MessageLibType } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLib.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+import { MessageLibBase } from "./MessageLibBase.sol";
+
+/// @dev receive-side message library base contract on endpoint v2.
+/// it does not have the complication as the one of endpoint v1, such as nonce, executor whitelist, etc.
+abstract contract ReceiveLibBaseE2 is MessageLibBase, ERC165, IMessageLib {
+    using PacketV1Codec for bytes;
+
+    constructor(address _endpoint) MessageLibBase(_endpoint, ILayerZeroEndpointV2(_endpoint).eid()) {}
+
+    function supportsInterface(bytes4 _interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+        return _interfaceId == type(IMessageLib).interfaceId || super.supportsInterface(_interfaceId);
+    }
+
+    function messageLibType() external pure virtual override returns (MessageLibType) {
+        return MessageLibType.Receive;
+    }
+}

package/contracts/SendLibBase.sol

@@ -0,0 +1,258 @@
+// 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 { ILayerZeroExecutor } from "./interfaces/ILayerZeroExecutor.sol";
+import { ILayerZeroTreasury } from "./interfaces/ILayerZeroTreasury.sol";
+import { SafeCall } from "./libs/SafeCall.sol";
+import { MessageLibBase } from "./MessageLibBase.sol";
+
+struct WorkerOptions {
+    uint8 workerId;
+    bytes options;
+}
+
+struct SetDefaultExecutorConfigParam {
+    uint32 eid;
+    ExecutorConfig config;
+}
+
+struct ExecutorConfig {
+    uint32 maxMessageSize;
+    address executor;
+}
+
+/// @dev base contract for both SendLibBaseE1 and SendLibBaseE2
+abstract contract SendLibBase is MessageLibBase, Ownable {
+    using SafeCall for address;
+
+    address private constant DEFAULT_CONFIG = address(0);
+    uint16 internal constant TREASURY_MAX_COPY = 32;
+
+    uint256 internal immutable treasuryGasLimit;
+    uint256 internal treasuryNativeFeeCap;
+
+    // config
+    address public treasury;
+    mapping(address oapp => mapping(uint32 eid => ExecutorConfig)) public executorConfigs;
+
+    // accumulated fees for workers and treasury
+    mapping(address worker => uint256) public fees;
+
+    event ExecutorFeePaid(address executor, uint256 fee);
+    event TreasurySet(address treasury);
+    event DefaultExecutorConfigsSet(SetDefaultExecutorConfigParam[] params);
+    event ExecutorConfigSet(address oapp, uint32 eid, ExecutorConfig config);
+    event TreasuryNativeFeeCapSet(uint256 newTreasuryNativeFeeCap);
+
+    error LZ_MessageLib_InvalidMessageSize(uint256 actual, uint256 max);
+    error LZ_MessageLib_InvalidAmount(uint256 requested, uint256 available);
+    error LZ_MessageLib_TransferFailed();
+    error LZ_MessageLib_InvalidExecutor();
+    error LZ_MessageLib_ZeroMessageSize();
+
+    constructor(
+        address _endpoint,
+        uint32 _localEid,
+        uint256 _treasuryGasLimit,
+        uint256 _treasuryNativeFeeCap
+    ) MessageLibBase(_endpoint, _localEid) {
+        treasuryGasLimit = _treasuryGasLimit;
+        treasuryNativeFeeCap = _treasuryNativeFeeCap;
+    }
+
+    function setDefaultExecutorConfigs(SetDefaultExecutorConfigParam[] calldata _params) external onlyOwner {
+        for (uint256 i = 0; i < _params.length; ++i) {
+            SetDefaultExecutorConfigParam calldata param = _params[i];
+
+            if (param.config.executor == address(0x0)) revert LZ_MessageLib_InvalidExecutor();
+            if (param.config.maxMessageSize == 0) revert LZ_MessageLib_ZeroMessageSize();
+
+            executorConfigs[DEFAULT_CONFIG][param.eid] = param.config;
+        }
+        emit DefaultExecutorConfigsSet(_params);
+    }
+
+    /// @dev the new value can not be greater than the old value, i.e. down only
+    function setTreasuryNativeFeeCap(uint256 _newTreasuryNativeFeeCap) external onlyOwner {
+        // assert the new value is no greater than the old value
+        if (_newTreasuryNativeFeeCap > treasuryNativeFeeCap)
+            revert LZ_MessageLib_InvalidAmount(_newTreasuryNativeFeeCap, treasuryNativeFeeCap);
+        treasuryNativeFeeCap = _newTreasuryNativeFeeCap;
+        emit TreasuryNativeFeeCapSet(_newTreasuryNativeFeeCap);
+    }
+
+    // ============================ View ===================================
+    // @dev get the executor config and if not set, return the default config
+    function getExecutorConfig(address _oapp, uint32 _remoteEid) public view returns (ExecutorConfig memory rtnConfig) {
+        ExecutorConfig storage defaultConfig = executorConfigs[DEFAULT_CONFIG][_remoteEid];
+        ExecutorConfig storage customConfig = executorConfigs[_oapp][_remoteEid];
+
+        uint32 maxMessageSize = customConfig.maxMessageSize;
+        rtnConfig.maxMessageSize = maxMessageSize != 0 ? maxMessageSize : defaultConfig.maxMessageSize;
+
+        address executor = customConfig.executor;
+        rtnConfig.executor = executor != address(0x0) ? executor : defaultConfig.executor;
+    }
+
+    // ======================= Internal =======================
+    function _assertMessageSize(uint256 _actual, uint256 _max) internal pure {
+        if (_actual > _max) revert LZ_MessageLib_InvalidMessageSize(_actual, _max);
+    }
+
+    function _payExecutor(
+        address _executor,
+        uint32 _dstEid,
+        address _sender,
+        uint256 _msgSize,
+        bytes memory _executorOptions
+    ) internal returns (uint256 executorFee) {
+        executorFee = ILayerZeroExecutor(_executor).assignJob(_dstEid, _sender, _msgSize, _executorOptions);
+        if (executorFee > 0) {
+            fees[_executor] += executorFee;
+        }
+        emit ExecutorFeePaid(_executor, executorFee);
+    }
+
+    function _payTreasury(
+        address _sender,
+        uint32 _dstEid,
+        uint256 _totalNativeFee,
+        bool _payInLzToken
+    ) internal returns (uint256 treasuryNativeFee, uint256 lzTokenFee) {
+        if (treasury != address(0x0)) {
+            bytes memory callData = abi.encodeCall(
+                ILayerZeroTreasury.payFee,
+                (_sender, _dstEid, _totalNativeFee, _payInLzToken)
+            );
+            (bool success, bytes memory result) = treasury.safeCall(treasuryGasLimit, 0, TREASURY_MAX_COPY, callData);
+
+            (treasuryNativeFee, lzTokenFee) = _parseTreasuryResult(_totalNativeFee, _payInLzToken, success, result);
+            // fee should be in lzTokenFee if payInLzToken, otherwise in native
+            if (treasuryNativeFee > 0) {
+                fees[treasury] += treasuryNativeFee;
+            }
+        }
+    }
+
+    /// @dev the abstract process for quote() is:
+    /// 0/ split out the executor options and options of other workers
+    /// 1/ quote workers
+    /// 2/ quote executor
+    /// 3/ quote treasury
+    /// @return nativeFee, lzTokenFee
+    function _quote(
+        address _sender,
+        uint32 _dstEid,
+        uint256 _msgSize,
+        bool _payInLzToken,
+        bytes calldata _options
+    ) internal view returns (uint256, uint256) {
+        (bytes memory executorOptions, WorkerOptions[] memory validationOptions) = _splitOptions(_options);
+
+        // quote the verifier used in the library. for ULN, it is a list of DVNs
+        uint256 nativeFee = _quoteVerifier(_sender, _dstEid, validationOptions);
+
+        // quote executor
+        ExecutorConfig memory config = getExecutorConfig(_sender, _dstEid);
+        // assert msg size
+        _assertMessageSize(_msgSize, config.maxMessageSize);
+
+        nativeFee += ILayerZeroExecutor(config.executor).getFee(_dstEid, _sender, _msgSize, executorOptions);
+
+        // quote treasury
+        (uint256 treasuryNativeFee, uint256 lzTokenFee) = _quoteTreasury(_sender, _dstEid, nativeFee, _payInLzToken);
+        nativeFee += treasuryNativeFee;
+
+        return (nativeFee, lzTokenFee);
+    }
+
+    /// @dev this interface should be DoS-free if the user is paying with native. properties
+    /// 1/ treasury can return an overly high lzToken fee
+    /// 2/ if treasury returns an overly high native fee, it will be capped by maxNativeFee,
+    ///    which can be reasoned with the configurations
+    /// 3/ the owner can not configure the treasury in a way that force this function to revert
+    function _quoteTreasury(
+        address _sender,
+        uint32 _dstEid,
+        uint256 _totalNativeFee,
+        bool _payInLzToken
+    ) internal view returns (uint256 nativeFee, uint256 lzTokenFee) {
+        // treasury must be set, and it has to be a contract
+        if (treasury != address(0x0)) {
+            bytes memory callData = abi.encodeCall(
+                ILayerZeroTreasury.getFee,
+                (_sender, _dstEid, _totalNativeFee, _payInLzToken)
+            );
+            (bool success, bytes memory result) = treasury.safeStaticCall(
+                treasuryGasLimit,
+                TREASURY_MAX_COPY,
+                callData
+            );
+
+            return _parseTreasuryResult(_totalNativeFee, _payInLzToken, success, result);
+        }
+    }
+
+    function _parseTreasuryResult(
+        uint256 _totalNativeFee,
+        bool _payInLzToken,
+        bool _success,
+        bytes memory _result
+    ) internal view returns (uint256 nativeFee, uint256 lzTokenFee) {
+        // failure, charges nothing
+        if (!_success || _result.length < TREASURY_MAX_COPY) return (0, 0);
+
+        // parse the result
+        uint256 treasureFeeQuote = abi.decode(_result, (uint256));
+        if (_payInLzToken) {
+            lzTokenFee = treasureFeeQuote;
+        } else {
+            // pay in native
+            // we must prevent high-treasuryFee Dos attack
+            // nativeFee = min(treasureFeeQuote, maxNativeFee)
+            // opportunistically raise the maxNativeFee to be the same as _totalNativeFee
+            // can't use the _totalNativeFee alone because the oapp can use custom workers to force the fee to 0.
+            // maxNativeFee = max (_totalNativeFee, treasuryNativeFeeCap)
+            uint256 maxNativeFee = _totalNativeFee > treasuryNativeFeeCap ? _totalNativeFee : treasuryNativeFeeCap;
+
+            // min (treasureFeeQuote, nativeFeeCap)
+            nativeFee = treasureFeeQuote > maxNativeFee ? maxNativeFee : treasureFeeQuote;
+        }
+    }
+
+    /// @dev authenticated by msg.sender only
+    function _debitFee(uint256 _amount) internal {
+        uint256 fee = fees[msg.sender];
+        if (_amount > fee) revert LZ_MessageLib_InvalidAmount(_amount, fee);
+        unchecked {
+            fees[msg.sender] = fee - _amount;
+        }
+    }
+
+    function _setTreasury(address _treasury) internal {
+        treasury = _treasury;
+        emit TreasurySet(_treasury);
+    }
+
+    function _setExecutorConfig(uint32 _remoteEid, address _oapp, ExecutorConfig memory _config) internal {
+        executorConfigs[_oapp][_remoteEid] = _config;
+        emit ExecutorConfigSet(_oapp, _remoteEid, _config);
+    }
+
+    // ======================= Virtual =======================
+    /// @dev these two functions will be overridden with specific logics of the library function
+    function _quoteVerifier(
+        address _oapp,
+        uint32 _eid,
+        WorkerOptions[] memory _options
+    ) internal view virtual returns (uint256 nativeFee);
+
+    /// @dev this function will split the options into executorOptions and validationOptions
+    function _splitOptions(
+        bytes calldata _options
+    ) internal view virtual returns (bytes memory executorOptions, WorkerOptions[] memory validationOptions);
+}