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

package/contracts/uln/dvn/DVN.sol

@@ -0,0 +1,393 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { ILayerZeroUltraLightNodeV2 } from "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroUltraLightNodeV2.sol";
+
+import { Worker } from "../../Worker.sol";
+import { MultiSig } from "./MultiSig.sol";
+import { ReadLib1002 } from "../readlib/ReadLib1002.sol";
+import { IDVN } from "../interfaces/IDVN.sol";
+import { IDVNFeeLib } from "../interfaces/IDVNFeeLib.sol";
+import { IReceiveUlnE2 } from "../interfaces/IReceiveUlnE2.sol";
+
+struct ExecuteParam {
+    uint32 vid;
+    address target;
+    bytes callData;
+    uint256 expiration;
+    bytes signatures;
+}
+
+contract DVN is Worker, MultiSig, IDVN {
+    // to uniquely identify this DVN instance
+    // set to endpoint v1 eid if available OR endpoint v2 eid % 30_000
+    uint32 public immutable vid;
+    uint32 public immutable localEidV2; // endpoint-v2 only, for read call
+
+    mapping(uint32 dstEid => DstConfig) public dstConfig;
+    mapping(bytes32 executableHash => bool used) public usedHashes;
+
+    error DVN_OnlySelf();
+    error DVN_InvalidRole(bytes32 role);
+    error DVN_InstructionExpired();
+    error DVN_InvalidTarget(address target);
+    error DVN_InvalidVid(uint32 vid);
+    error DVN_InvalidSignatures();
+    error DVN_DuplicatedHash(bytes32 executableHash);
+
+    event VerifySignaturesFailed(uint256 idx);
+    event ExecuteFailed(uint256 _index, bytes _data);
+    event HashAlreadyUsed(ExecuteParam param, bytes32 _hash);
+    // same as DVNFeePaid, but for ULNv2
+    event VerifierFeePaid(uint256 fee);
+
+    // ========================= Constructor =========================
+
+    /// @dev DVN doesn't have a roleAdmin (address(0x0))
+    /// @dev Supports all of ULNv2, ULN301, ULN302 and more
+    /// @param _localEidV2 local endpoint-v2 eid
+    /// @param _vid unique identifier for this DVN instance
+    /// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
+    /// @param _priceFeed price feed address
+    /// @param _signers array of signer addresses for multisig
+    /// @param _quorum quorum for multisig
+    /// @param _admins array of admin addresses that are granted the ADMIN_ROLE
+    constructor(
+        uint32 _localEidV2,
+        uint32 _vid,
+        address[] memory _messageLibs,
+        address _priceFeed,
+        address[] memory _signers,
+        uint64 _quorum,
+        address[] memory _admins
+    ) Worker(_messageLibs, _priceFeed, 12000, address(0x0), _admins) MultiSig(_signers, _quorum) {
+        vid = _vid;
+        localEidV2 = _localEidV2;
+    }
+
+    // ========================= Modifier =========================
+
+    /// @dev depending on role, restrict access to only self or admin
+    /// @dev ALLOWLIST, DENYLIST, MESSAGE_LIB_ROLE can only be granted/revoked by self
+    /// @dev ADMIN_ROLE can only be granted/revoked by admin
+    /// @dev reverts if not one of the above roles
+    /// @param _role role to check
+    modifier onlySelfOrAdmin(bytes32 _role) {
+        if (_role == ALLOWLIST || _role == DENYLIST || _role == MESSAGE_LIB_ROLE) {
+            // self required
+            if (address(this) != msg.sender) {
+                revert DVN_OnlySelf();
+            }
+        } else if (_role == ADMIN_ROLE) {
+            // admin required
+            _checkRole(ADMIN_ROLE);
+        } else {
+            revert DVN_InvalidRole(_role);
+        }
+        _;
+    }
+
+    modifier onlySelf() {
+        if (address(this) != msg.sender) {
+            revert DVN_OnlySelf();
+        }
+        _;
+    }
+
+    // ========================= OnlySelf =========================
+
+    /// @dev set signers for multisig
+    /// @dev function sig 0x31cb6105
+    /// @param _signer signer address
+    /// @param _active true to add, false to remove
+    function setSigner(address _signer, bool _active) external onlySelf {
+        _setSigner(_signer, _active);
+    }
+
+    /// @dev set quorum for multisig
+    /// @dev function sig 0x8585c945
+    /// @param _quorum to set
+    function setQuorum(uint64 _quorum) external onlySelf {
+        _setQuorum(_quorum);
+    }
+
+    // ========================= OnlySelf / OnlyAdmin =========================
+
+    /// @dev overrides AccessControl to allow self/admin to grant role'
+    /// @dev function sig 0x2f2ff15d
+    /// @param _role role to grant
+    /// @param _account account to grant role to
+    function grantRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
+        _grantRole(_role, _account);
+    }
+
+    /// @dev overrides AccessControl to allow self/admin to revoke role
+    /// @dev function sig 0xd547741f
+    /// @param _role role to revoke
+    /// @param _account account to revoke role from
+    function revokeRole(bytes32 _role, address _account) public override onlySelfOrAdmin(_role) {
+        _revokeRole(_role, _account);
+    }
+
+    // ========================= OnlyQuorum =========================
+
+    /// @notice function for quorum to change admin without going through execute function
+    /// @dev calldata in the case is abi.encode new admin address
+    function quorumChangeAdmin(ExecuteParam calldata _param) external {
+        if (_param.expiration <= block.timestamp) {
+            revert DVN_InstructionExpired();
+        }
+        if (_param.target != address(this)) {
+            revert DVN_InvalidTarget(_param.target);
+        }
+        if (_param.vid != vid) {
+            revert DVN_InvalidVid(_param.vid);
+        }
+
+        // generate and validate hash
+        bytes32 hash = hashCallData(_param.vid, _param.target, _param.callData, _param.expiration);
+        (bool sigsValid, ) = verifySignatures(hash, _param.signatures);
+        if (!sigsValid) {
+            revert DVN_InvalidSignatures();
+        }
+        if (usedHashes[hash]) {
+            revert DVN_DuplicatedHash(hash);
+        }
+
+        usedHashes[hash] = true;
+        _grantRole(ADMIN_ROLE, abi.decode(_param.callData, (address)));
+    }
+
+    // ========================= OnlyAdmin =========================
+
+    /// @param _params array of DstConfigParam
+    function setDstConfig(DstConfigParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; ++i) {
+            DstConfigParam calldata param = _params[i];
+            dstConfig[param.dstEid] = DstConfig(param.gas, param.multiplierBps, param.floorMarginUSD);
+        }
+        emit SetDstConfig(_params);
+    }
+
+    /// @dev takes a list of instructions and executes them in order
+    /// @dev if any of the instructions fail, it will emit an error event and continue to execute the rest of the instructions
+    /// @param _params array of ExecuteParam, includes target, callData, expiration, signatures
+    function execute(ExecuteParam[] calldata _params) external onlyRole(ADMIN_ROLE) {
+        for (uint256 i = 0; i < _params.length; ++i) {
+            ExecuteParam calldata param = _params[i];
+            // 1. skip if invalid vid
+            if (param.vid != vid) {
+                continue;
+            }
+
+            // 2. skip if expired
+            if (param.expiration <= block.timestamp) {
+                continue;
+            }
+
+            // generate and validate hash
+            bytes32 hash = hashCallData(param.vid, param.target, param.callData, param.expiration);
+
+            // 3. check signatures
+            (bool sigsValid, ) = verifySignatures(hash, param.signatures);
+            if (!sigsValid) {
+                emit VerifySignaturesFailed(i);
+                continue;
+            }
+
+            // 4. should check hash
+            bool shouldCheckHash = _shouldCheckHash(bytes4(param.callData));
+            if (shouldCheckHash) {
+                if (usedHashes[hash]) {
+                    emit HashAlreadyUsed(param, hash);
+                    continue;
+                } else {
+                    usedHashes[hash] = true; // prevent reentry and replay attack
+                }
+            }
+
+            (bool success, bytes memory rtnData) = param.target.call(param.callData);
+            if (!success) {
+                if (shouldCheckHash) {
+                    // need to unset the usedHash otherwise it cant be used
+                    usedHashes[hash] = false;
+                }
+                // emit an event in any case
+                emit ExecuteFailed(i, rtnData);
+            }
+        }
+    }
+
+    /// @dev to support ULNv2
+    /// @dev the withdrawFee function for ULN30X is built in the Worker contract
+    /// @param _lib message lib address
+    /// @param _to address to withdraw to
+    /// @param _amount amount to withdraw
+    function withdrawFeeFromUlnV2(address _lib, address payable _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
+        if (!hasRole(MESSAGE_LIB_ROLE, _lib)) {
+            revert Worker_OnlyMessageLib();
+        }
+        ILayerZeroUltraLightNodeV2(_lib).withdrawNative(_to, _amount);
+    }
+
+    // ========================= OnlyMessageLib =========================
+
+    /// @dev for ULN301, ULN302 and more to assign job
+    /// @dev dvn network can reject job from _sender by adding/removing them from allowlist/denylist
+    /// @param _param assign job param
+    /// @param _options dvn options
+    function assignJob(
+        AssignJobParam calldata _param,
+        bytes calldata _options
+    ) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_param.sender) returns (uint256 totalFee) {
+        IDVNFeeLib.FeeParams memory feeParams = IDVNFeeLib.FeeParams(
+            priceFeed,
+            _param.dstEid,
+            _param.confirmations,
+            _param.sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        totalFee = IDVNFeeLib(workerFeeLib).getFeeOnSend(feeParams, dstConfig[_param.dstEid], _options);
+    }
+
+    /// @dev to support ULNv2
+    /// @dev dvn network can reject job from _sender by adding/removing them from allowlist/denylist
+    /// @param _dstEid destination EndpointId
+    /// @param //_outboundProofType outbound proof type
+    /// @param _confirmations block confirmations
+    /// @param _sender message sender address
+    function assignJob(
+        uint16 _dstEid,
+        uint16 /*_outboundProofType*/,
+        uint64 _confirmations,
+        address _sender
+    ) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint256 totalFee) {
+        IDVNFeeLib.FeeParams memory params = IDVNFeeLib.FeeParams(
+            priceFeed,
+            _dstEid,
+            _confirmations,
+            _sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        // ULNV2 does not have dvn options
+        totalFee = IDVNFeeLib(workerFeeLib).getFeeOnSend(params, dstConfig[_dstEid], bytes(""));
+        emit VerifierFeePaid(totalFee);
+    }
+
+    /// @dev to support ReadLib
+    // @param _packetHeader - version + nonce + path
+    // @param _cmd - the command to be executed to obtain the payload
+    // @param _options - options
+    function assignJob(
+        address _sender,
+        bytes calldata /*_packetHeader*/,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external payable onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) returns (uint256 fee) {
+        IDVNFeeLib.FeeParamsForRead memory feeParams = IDVNFeeLib.FeeParamsForRead(
+            priceFeed,
+            _sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        fee = IDVNFeeLib(workerFeeLib).getFeeOnSend(feeParams, dstConfig[localEidV2], _cmd, _options);
+    }
+
+    // ========================= View =========================
+
+    /// @dev getFee can revert if _sender doesn't pass ACL
+    /// @param _dstEid destination EndpointId
+    /// @param _confirmations block confirmations
+    /// @param _sender message sender address
+    /// @param _options dvn options
+    /// @return fee fee in native amount
+    function getFee(
+        uint32 _dstEid,
+        uint64 _confirmations,
+        address _sender,
+        bytes calldata _options
+    ) external view onlyAcl(_sender) returns (uint256 fee) {
+        IDVNFeeLib.FeeParams memory params = IDVNFeeLib.FeeParams(
+            priceFeed,
+            _dstEid,
+            _confirmations,
+            _sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        fee = IDVNFeeLib(workerFeeLib).getFee(params, dstConfig[_dstEid], _options);
+    }
+
+    /// @dev to support ULNv2
+    /// @dev getFee can revert if _sender doesn't pass ACL
+    /// @param _dstEid destination EndpointId
+    /// @param //_outboundProofType outbound proof type
+    /// @param _confirmations block confirmations
+    /// @param _sender message sender address
+    function getFee(
+        uint16 _dstEid,
+        uint16 /*_outboundProofType*/,
+        uint64 _confirmations,
+        address _sender
+    ) public view onlyAcl(_sender) returns (uint256 fee) {
+        IDVNFeeLib.FeeParams memory params = IDVNFeeLib.FeeParams(
+            priceFeed,
+            _dstEid,
+            _confirmations,
+            _sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        fee = IDVNFeeLib(workerFeeLib).getFee(params, dstConfig[_dstEid], bytes(""));
+    }
+
+    /// @dev to support ReadLib
+    // @param _packetHeader - version + nonce + path
+    // @param _cmd - the command to be executed to obtain the payload
+    // @param _options - options
+    function getFee(
+        address _sender,
+        bytes calldata /*_packetHeader*/,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external view onlyAcl(_sender) returns (uint256 fee) {
+        IDVNFeeLib.FeeParamsForRead memory feeParams = IDVNFeeLib.FeeParamsForRead(
+            priceFeed,
+            _sender,
+            quorum,
+            defaultMultiplierBps
+        );
+        fee = IDVNFeeLib(workerFeeLib).getFee(feeParams, dstConfig[localEidV2], _cmd, _options);
+    }
+
+    /// @param _target target address
+    /// @param _callData call data
+    /// @param _expiration expiration timestamp
+    /// @return hash of above
+    function hashCallData(
+        uint32 _vid,
+        address _target,
+        bytes calldata _callData,
+        uint256 _expiration
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_vid, _target, _expiration, _callData));
+    }
+
+    // ========================= Internal =========================
+
+    /// @dev to save gas, we don't check hash for some functions (where replaying won't change the state)
+    /// @dev for example, some administrative functions like changing signers, the contract should check hash to double spending
+    /// @dev should ensure that all onlySelf functions have unique functionSig
+    /// @param _functionSig function signature
+    /// @return true if should check hash
+    function _shouldCheckHash(bytes4 _functionSig) internal pure returns (bool) {
+        // never check for these selectors to save gas
+        return
+            _functionSig != IReceiveUlnE2.verify.selector && // 0x0223536e, replaying won't change the state
+            _functionSig != ReadLib1002.verify.selector && // 0xab750e75, replaying won't change the state
+            _functionSig != ILayerZeroUltraLightNodeV2.updateHash.selector; // 0x704316e5, replaying will be revert at uln
+    }
+}

package/contracts/uln/dvn/DVNFeeLib.sol

@@ -0,0 +1,288 @@
+// 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 { IDVN } from "../interfaces/IDVN.sol";
+import { IDVNFeeLib } from "../interfaces/IDVNFeeLib.sol";
+import { DVNOptions } from "../libs/DVNOptions.sol";
+import { ReadCmdCodecV1 } from "../libs/ReadCmdCodecV1.sol";
+import { SupportedCmdTypesLib, SupportedCmdTypes, BitMap256 } from "../libs/SupportedCmdTypes.sol";
+
+contract DVNFeeLib is Ownable, IDVNFeeLib {
+    using DVNOptions for bytes;
+
+    struct SetSupportedCmdTypesParam {
+        uint32 targetEid;
+        BitMap256 types;
+    }
+
+    struct BlockTimeConfig {
+        uint32 avgBlockTime; // milliseconds
+        uint64 blockNum; // the block number of the reference timestamp
+        uint64 timestamp; // second, the reference timestamp of the block number
+        uint32 maxPastRetention; // second, the max retention time the DVN will accept read requests/compute from the past time
+        uint32 maxFutureRetention; // second, the max retention time the DVN will accept read requests/compute from the future time
+    }
+
+    uint16 internal constant BPS_BASE = 10000;
+
+    // encoded( execute(ExecuteParam[]) ): funcSigHash + params -> 4  + 32(Offset of the array) + 32(array size) + 32(first element start offset)\
+    // + 32(vid) + 32(target) + 32(calldata-offset) + 32(expiration) + 32(signatures-offset) = 260
+    uint16 internal constant EXECUTE_FIXED_BYTES = 260;
+    uint16 internal constant SIGNATURE_RAW_BYTES = 65; // not encoded
+    // verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations)\
+    // 4 + 32(header offset) + 32(payloadHash) + 32(confirmations, 8 -> 32 padded) + 32(header-size) + 96(81 -> header-padded) = 228,
+    // padded to multiples of 32 = 256, encoded as bytes with an 32 byte for the bytes size = 288
+    uint16 internal constant VERIFY_BYTES_ULN = 288;
+    // verify(bytes calldata _packetHeader, bytes32 _cmdHash, bytes32 _payloadHash)\
+    // 4 + 32(header offset) + 32(cmdHash) + 32(payloadHash) + 32(header-size) + 96(81 -> header-padded) = 228,
+    // padded to multiples of 32 = 256, encoded as bytes with an 32 byte for the bytes size = 288
+    uint16 internal constant VERIFY_BYTES_CMD_LIB = 288;
+
+    uint256 internal immutable nativeDecimalsRate;
+    uint32 internal immutable localEidV2; // endpoint-v2 only, for read call
+
+    SupportedCmdTypes internal supportedCmdTypes;
+
+    uint120 internal evmCallRequestV1FeeUSD;
+    uint120 internal evmCallComputeV1ReduceFeeUSD;
+    uint16 internal evmCallComputeV1MapBps;
+
+    mapping(uint32 dstEid => BlockTimeConfig) public dstBlockTimeConfigs;
+
+    constructor(uint32 _localEidV2, uint256 _nativeDecimalsRate) {
+        localEidV2 = _localEidV2;
+        nativeDecimalsRate = _nativeDecimalsRate;
+    }
+
+    // ================================ OnlyOwner ================================
+    function setSupportedCmdTypes(SetSupportedCmdTypesParam[] calldata _params) external onlyOwner {
+        for (uint256 i = 0; i < _params.length; i++) {
+            supportedCmdTypes.cmdTypes[_params[i].targetEid] = _params[i].types;
+        }
+    }
+
+    function getSupportedCmdTypes(uint32 _targetEid) external view returns (BitMap256) {
+        return supportedCmdTypes.cmdTypes[_targetEid];
+    }
+
+    function setDstBlockTimeConfigs(
+        uint32[] calldata dstEids,
+        BlockTimeConfig[] calldata _blockConfigs
+    ) external onlyOwner {
+        if (dstEids.length != _blockConfigs.length) revert DVN_INVALID_INPUT_LENGTH();
+        for (uint256 i = 0; i < dstEids.length; i++) {
+            dstBlockTimeConfigs[dstEids[i]] = _blockConfigs[i];
+        }
+    }
+
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyOwner {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+    }
+
+    function setCmdFees(
+        uint120 _evmCallRequestV1FeeUSD,
+        uint120 _evmCallComputeV1ReduceFeeUSD,
+        uint16 _evmCallComputeV1MapBps
+    ) external onlyOwner {
+        evmCallRequestV1FeeUSD = _evmCallRequestV1FeeUSD;
+        evmCallComputeV1ReduceFeeUSD = _evmCallComputeV1ReduceFeeUSD;
+        evmCallComputeV1MapBps = _evmCallComputeV1MapBps;
+    }
+
+    function getCmdFees() external view returns (uint120, uint120, uint16) {
+        return (evmCallRequestV1FeeUSD, evmCallComputeV1ReduceFeeUSD, evmCallComputeV1MapBps);
+    }
+
+    // ========================= External =========================
+    /// @dev get fee function that can change state. e.g. paying priceFeed
+    /// @param _params fee params
+    /// @param _dstConfig dst config
+    /// @param //_options options
+    function getFeeOnSend(
+        FeeParams calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) external payable returns (uint256) {
+        return getFee(_params, _dstConfig, _options);
+    }
+
+    function getFeeOnSend(
+        FeeParamsForRead calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) external payable returns (uint256 fee) {
+        fee = getFee(_params, _dstConfig, _cmd, _options);
+    }
+
+    // ========================= View =========================
+    /// @dev get fee view function
+    /// @param _params fee params
+    /// @param _dstConfig dst config
+    /// @param //_options options
+    function getFee(
+        FeeParams calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _options
+    ) public view returns (uint256) {
+        if (_dstConfig.gas == 0) revert DVN_EidNotSupported(_params.dstEid);
+
+        _decodeDVNOptions(_options); // validate options
+
+        uint256 callDataSize = _getCallDataSize(_params.quorum);
+        (uint256 fee, , , uint128 nativePriceUSD) = ILayerZeroPriceFeed(_params.priceFeed).estimateFeeByEid(
+            _params.dstEid,
+            callDataSize,
+            _dstConfig.gas
+        );
+        return
+            _applyPremium(
+                fee,
+                _dstConfig.multiplierBps,
+                _params.defaultMultiplierBps,
+                _dstConfig.floorMarginUSD,
+                nativePriceUSD
+            );
+    }
+
+    function getFee(
+        FeeParamsForRead calldata _params,
+        IDVN.DstConfig calldata _dstConfig,
+        bytes calldata _cmd,
+        bytes calldata _options
+    ) public view returns (uint256) {
+        if (_dstConfig.gas == 0) revert DVN_EidNotSupported(localEidV2);
+
+        _decodeDVNOptions(_options); // validate options
+
+        uint256 callDataSize = _getReadCallDataSize(_params.quorum);
+        (uint256 fee, , , uint128 nativePriceUSD) = ILayerZeroPriceFeed(_params.priceFeed).estimateFeeByEid(
+            localEidV2,
+            callDataSize,
+            _dstConfig.gas
+        );
+
+        // cmdFeeUSD -> cmdFee native final
+        uint256 cmdFeeUSD = _estimateCmdFee(_cmd);
+        uint256 cmdFee = (cmdFeeUSD * nativeDecimalsRate) / nativePriceUSD;
+
+        return
+            _applyPremium(
+                fee + cmdFee,
+                _dstConfig.multiplierBps,
+                _params.defaultMultiplierBps,
+                _dstConfig.floorMarginUSD,
+                nativePriceUSD
+            );
+    }
+
+    // ========================= Internal =========================
+    function _getCallDataSize(uint256 _quorum) internal pure returns (uint256) {
+        return _getCallDataSizeByQuorumAndVerifyBytes(_quorum, VERIFY_BYTES_ULN);
+    }
+
+    function _getReadCallDataSize(uint256 _quorum) internal pure returns (uint256) {
+        return _getCallDataSizeByQuorumAndVerifyBytes(_quorum, VERIFY_BYTES_CMD_LIB);
+    }
+
+    function _getCallDataSizeByQuorumAndVerifyBytes(
+        uint256 _quorum,
+        uint256 verifyBytes
+    ) internal pure returns (uint256) {
+        uint256 totalSignatureBytes = _quorum * SIGNATURE_RAW_BYTES;
+        if (totalSignatureBytes % 32 != 0) {
+            totalSignatureBytes = totalSignatureBytes - (totalSignatureBytes % 32) + 32;
+        }
+        // getFee should charge on execute(updateHash)
+        // totalSignatureBytesPadded also has 32 as size of the bytes
+        return uint256(EXECUTE_FIXED_BYTES) + verifyBytes + totalSignatureBytes + 32;
+    }
+
+    function _applyPremium(
+        uint256 _fee,
+        uint16 _bps,
+        uint16 _defaultBps,
+        uint128 _marginUSD,
+        uint128 _nativePriceUSD
+    ) internal view returns (uint256) {
+        uint16 multiplierBps = _bps == 0 ? _defaultBps : _bps;
+
+        uint256 feeWithMultiplier = (_fee * multiplierBps) / 10000;
+        if (_nativePriceUSD == 0 || _marginUSD == 0) {
+            return feeWithMultiplier;
+        }
+
+        uint256 feeWithFloorMargin = _fee + (_marginUSD * nativeDecimalsRate) / _nativePriceUSD;
+
+        return feeWithFloorMargin > feeWithMultiplier ? feeWithFloorMargin : feeWithMultiplier;
+    }
+
+    function _decodeDVNOptions(bytes calldata _options) internal pure returns (uint256) {
+        uint256 cursor;
+        while (cursor < _options.length) {
+            (uint8 optionType, , uint256 newCursor) = _options.nextDVNOption(cursor);
+            cursor = newCursor;
+            revert DVN_UnsupportedOptionType(optionType);
+        }
+        if (cursor != _options.length) revert DVNOptions.DVN_InvalidDVNOptions(cursor);
+
+        return 0; // todo: precrime fee model
+    }
+
+    function _estimateCmdFee(bytes calldata _cmd) internal view returns (uint256 fee) {
+        ReadCmdCodecV1.Cmd memory cmd = ReadCmdCodecV1.decode(_cmd, _assertCmdTypeSupported);
+        fee = cmd.numEvmCallRequestV1 * evmCallRequestV1FeeUSD;
+        if (cmd.evmCallComputeV1Map) {
+            fee += (fee * evmCallComputeV1MapBps) / BPS_BASE;
+        }
+        if (cmd.evmCallComputeV1Reduce) {
+            fee += evmCallComputeV1ReduceFeeUSD;
+        }
+    }
+
+    function _assertCmdTypeSupported(
+        uint32 _targetEid,
+        bool _isBlockNum,
+        uint64 _blockNumOrTimestamp,
+        uint8 _cmdType
+    ) internal view {
+        supportedCmdTypes.assertSupported(_targetEid, _cmdType);
+        if (supportedCmdTypes.isSupported(_targetEid, SupportedCmdTypesLib.CMD_V1__TIMESTAMP_VALIDATE)) {
+            BlockTimeConfig memory blockCnf = dstBlockTimeConfigs[_targetEid];
+            uint64 timestamp = _blockNumOrTimestamp;
+            if (_isBlockNum) {
+                // convert the blockNum to the timestamp
+                if (_blockNumOrTimestamp > blockCnf.blockNum) {
+                    timestamp =
+                        blockCnf.timestamp +
+                        ((_blockNumOrTimestamp - blockCnf.blockNum) * blockCnf.avgBlockTime) /
+                        1000;
+                } else {
+                    timestamp =
+                        blockCnf.timestamp -
+                        ((blockCnf.blockNum - _blockNumOrTimestamp) * blockCnf.avgBlockTime) /
+                        1000;
+                }
+            }
+            if (
+                timestamp + blockCnf.maxPastRetention < block.timestamp ||
+                timestamp > block.timestamp + blockCnf.maxFutureRetention
+            ) {
+                revert DVN_TimestampOutOfRange(_targetEid, timestamp);
+            }
+        }
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor) {
+        return (1, 1);
+    }
+
+    // send funds here to pay for price feed directly
+    receive() external payable {}
+}