@layerzerolabs/lz-evm-messagelib-v2 2.0.2

package/contracts/interfaces/IExecutorFeeLib.sol

@@ -0,0 +1,32 @@
+// 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;
+    }
+
+    error NoOptions();
+    error NativeAmountExceedsCap(uint256 amount, uint256 cap);
+    error UnsupportedOptionType(uint8 optionType);
+    error InvalidExecutorOptions(uint256 cursor);
+
+    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);
+}

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 OnlyPriceUpdater();
+    error InsufficientFee(uint256 provided, uint256 required);
+    error UnknownL2Eid(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/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 NotAllowed();
+    error OnlyMessageLib();
+    error 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);
+}

package/contracts/libs/SafeCall.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.22;
+
+/// @dev copied from https://github.com/nomad-xyz/ExcessivelySafeCall/blob/main/src/ExcessivelySafeCall.sol.
+library SafeCall {
+    /// @notice calls a contract with a specified gas limit and value and captures the return data
+    /// @param _target The address to call
+    /// @param _gas The amount of gas to forward to the remote contract
+    /// @param _value The value in wei to send to the remote contract
+    /// to memory.
+    /// @param _maxCopy The maximum number of bytes of returndata to copy
+    /// to memory.
+    /// @param _calldata The data to send to the remote contract
+    /// @return success and returndata, as `.call()`. Returndata is capped to
+    /// `_maxCopy` bytes.
+    function safeCall(
+        address _target,
+        uint256 _gas,
+        uint256 _value,
+        uint16 _maxCopy,
+        bytes memory _calldata
+    ) internal returns (bool, bytes memory) {
+        // check that target has code
+        uint size;
+        assembly {
+            size := extcodesize(_target)
+        }
+        if (size == 0) {
+            return (false, new bytes(0));
+        }
+
+        // set up for assembly call
+        uint256 _toCopy;
+        bool _success;
+        bytes memory _returnData = new bytes(_maxCopy);
+        // dispatch message to recipient
+        // by assembly calling "handle" function
+        // we call via assembly to avoid memcopying a very large returndata
+        // returned by a malicious contract
+        assembly {
+            _success := call(
+                _gas, // gas
+                _target, // recipient
+                _value, // ether value
+                add(_calldata, 0x20), // inloc
+                mload(_calldata), // inlen
+                0, // outloc
+                0 // outlen
+            )
+            // limit our copy to 100 bytes
+            _toCopy := returndatasize()
+            if gt(_toCopy, _maxCopy) {
+                _toCopy := _maxCopy
+            }
+            // Store the length of the copied bytes
+            mstore(_returnData, _toCopy)
+            // copy the bytes from returndata[0:_toCopy]
+            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
+        }
+        return (_success, _returnData);
+    }
+
+    /// @notice Use when you _really_ really _really_ don't trust the called
+    /// contract. This prevents the called contract from causing reversion of
+    /// the caller in as many ways as we can.
+    /// @dev The main difference between this and a solidity low-level call is
+    /// that we limit the number of bytes that the callee can cause to be
+    /// copied to caller memory. This prevents stupid things like malicious
+    /// contracts returning 10,000,000 bytes causing a local OOG when copying
+    /// to memory.
+    /// @param _target The address to call
+    /// @param _gas The amount of gas to forward to the remote contract
+    /// @param _maxCopy The maximum number of bytes of returndata to copy
+    /// to memory.
+    /// @param _calldata The data to send to the remote contract
+    /// @return success and returndata, as `.call()`. Returndata is capped to
+    /// `_maxCopy` bytes.
+    function safeStaticCall(
+        address _target,
+        uint256 _gas,
+        uint16 _maxCopy,
+        bytes memory _calldata
+    ) internal view returns (bool, bytes memory) {
+        // check that target has code
+        uint size;
+        assembly {
+            size := extcodesize(_target)
+        }
+        if (size == 0) {
+            return (false, new bytes(0));
+        }
+
+        // set up for assembly call
+        uint256 _toCopy;
+        bool _success;
+        bytes memory _returnData = new bytes(_maxCopy);
+        // dispatch message to recipient
+        // by assembly calling "handle" function
+        // we call via assembly to avoid memcopying a very large returndata
+        // returned by a malicious contract
+        assembly {
+            _success := staticcall(
+                _gas, // gas
+                _target, // recipient
+                add(_calldata, 0x20), // inloc
+                mload(_calldata), // inlen
+                0, // outloc
+                0 // outlen
+            )
+            // limit our copy to 256 bytes
+            _toCopy := returndatasize()
+            if gt(_toCopy, _maxCopy) {
+                _toCopy := _maxCopy
+            }
+            // Store the length of the copied bytes
+            mstore(_returnData, _toCopy)
+            // copy the bytes from returndata[0:_toCopy]
+            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
+        }
+        return (_success, _returnData);
+    }
+}

package/contracts/uln/LzExecutor.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity 0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { IReceiveUlnE2 } from "./interfaces/IReceiveUlnE2.sol";
+import { ILayerZeroEndpointV2, ExecutionState, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { VerificationState } from "./ReceiveUlnBase.sol";
+
+struct LzReceiveParam {
+    Origin origin;
+    address receiver;
+    bytes32 guid;
+    bytes message;
+    bytes extraData;
+    uint256 gas;
+    uint256 value;
+}
+
+struct NativeDropParam {
+    address _receiver;
+    uint256 _amount;
+}
+
+contract LzExecutor is Ownable {
+    address public immutable receiveUln302;
+    ILayerZeroEndpointV2 public immutable endpoint;
+    uint32 public immutable localEid;
+
+    error Executed();
+    error Verifying();
+
+    constructor(address _receiveUln302, address _endpoint) {
+        receiveUln302 = _receiveUln302;
+        endpoint = ILayerZeroEndpointV2(_endpoint);
+        localEid = endpoint.eid();
+    }
+
+    /// @notice process for commit and execute
+    /// 1. check if executable, revert if executed, execute if executable
+    /// 2. check if verifiable, revert if verifying, commit if verifiable
+    /// 3. native drop
+    /// 4. try execute, will revert if not executable
+    function commitAndExecute(
+        address _receiveLib,
+        LzReceiveParam calldata _lzReceiveParam,
+        NativeDropParam calldata _nativeDropParam
+    ) external payable {
+        /// 1. check if executable, revert if executed
+        ExecutionState executionState = endpoint.executable(_lzReceiveParam.origin, _lzReceiveParam.receiver);
+        if (executionState == ExecutionState.Executed) revert Executed();
+
+        /// 2. if not executable, check if verifiable, revert if verifying, commit if verifiable
+        if (executionState != ExecutionState.Executable) {
+            address receiveLib = receiveUln302 == address(0x0) ? _receiveLib : address(receiveUln302);
+            bytes memory packetHeader = abi.encodePacked(
+                uint8(1), // packet version 1
+                _lzReceiveParam.origin.nonce,
+                _lzReceiveParam.origin.srcEid,
+                _lzReceiveParam.origin.sender,
+                localEid,
+                bytes32(uint256(uint160(_lzReceiveParam.receiver)))
+            );
+            bytes32 payloadHash = keccak256(abi.encodePacked(_lzReceiveParam.guid, _lzReceiveParam.message));
+
+            VerificationState verificationState = IReceiveUlnE2(receiveLib).verifiable(packetHeader, payloadHash);
+            if (verificationState == VerificationState.Verifiable) {
+                // verification required
+                IReceiveUlnE2(receiveLib).commitVerification(packetHeader, payloadHash);
+            } else if (verificationState == VerificationState.Verifying) {
+                revert Verifying();
+            }
+        }
+
+        /// 3. native drop
+        if (_nativeDropParam._amount > 0 && _nativeDropParam._receiver != address(0x0)) {
+            Transfer.native(_nativeDropParam._receiver, _nativeDropParam._amount);
+        }
+
+        /// 4. try execute, will revert if not executable
+        endpoint.lzReceive{ gas: _lzReceiveParam.gas, value: _lzReceiveParam.value }(
+            _lzReceiveParam.origin,
+            _lzReceiveParam.receiver,
+            _lzReceiveParam.guid,
+            _lzReceiveParam.message,
+            _lzReceiveParam.extraData
+        );
+    }
+
+    function withdrawNative(address _to, uint256 _amount) external onlyOwner {
+        Transfer.native(_to, _amount);
+    }
+}

package/contracts/uln/ReceiveUlnBase.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+import { UlnBase, UlnConfig } from "./UlnBase.sol";
+
+enum VerificationState {
+    Verifying,
+    Verifiable,
+    Verified
+}
+
+struct Verification {
+    bool submitted;
+    uint64 confirmations;
+}
+
+/// @dev includes the utility functions for checking ULN states and logics
+abstract contract ReceiveUlnBase is UlnBase {
+    using PacketV1Codec for bytes;
+
+    mapping(bytes32 headerHash => mapping(bytes32 payloadHash => mapping(address dvn => Verification)))
+        public hashLookup;
+
+    event PayloadVerified(address dvn, bytes header, uint256 confirmations, bytes32 proofHash);
+
+    error InvalidPacketHeader();
+    error InvalidPacketVersion();
+    error InvalidEid();
+    error Verifying();
+
+    // ============================ Internal ===================================
+    /// @dev per DVN signing function
+    function _verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) internal {
+        hashLookup[keccak256(_packetHeader)][_payloadHash][msg.sender] = Verification(true, _confirmations);
+        emit PayloadVerified(msg.sender, _packetHeader, _confirmations, _payloadHash);
+    }
+
+    function _verified(
+        address _dvn,
+        bytes32 _headerHash,
+        bytes32 _payloadHash,
+        uint64 _requiredConfirmation
+    ) internal view returns (bool verified) {
+        Verification memory verification = hashLookup[_headerHash][_payloadHash][_dvn];
+        // return true if the dvn has signed enough confirmations
+        verified = verification.submitted && verification.confirmations >= _requiredConfirmation;
+    }
+
+    function _verifyAndReclaimStorage(UlnConfig memory _config, bytes32 _headerHash, bytes32 _payloadHash) internal {
+        if (!_checkVerifiable(_config, _headerHash, _payloadHash)) {
+            revert Verifying();
+        }
+
+        // iterate the required DVNs
+        if (_config.requiredDVNCount > 0) {
+            for (uint8 i = 0; i < _config.requiredDVNCount; ++i) {
+                delete hashLookup[_headerHash][_payloadHash][_config.requiredDVNs[i]];
+            }
+        }
+
+        // iterate the optional DVNs
+        if (_config.optionalDVNCount > 0) {
+            for (uint8 i = 0; i < _config.optionalDVNCount; ++i) {
+                delete hashLookup[_headerHash][_payloadHash][_config.optionalDVNs[i]];
+            }
+        }
+    }
+
+    function _assertHeader(bytes calldata _packetHeader, uint32 _localEid) internal pure {
+        // assert packet header is of right size 81
+        if (_packetHeader.length != 81) revert InvalidPacketHeader();
+        // assert packet header version is the same as ULN
+        if (_packetHeader.version() != PacketV1Codec.PACKET_VERSION) revert InvalidPacketVersion();
+        // assert the packet is for this endpoint
+        if (_packetHeader.dstEid() != _localEid) revert InvalidEid();
+    }
+
+    /// @dev for verifiable view function
+    /// @dev checks if this verification is ready to be committed to the endpoint
+    function _checkVerifiable(
+        UlnConfig memory _config,
+        bytes32 _headerHash,
+        bytes32 _payloadHash
+    ) internal view returns (bool) {
+        // iterate the required DVNs
+        if (_config.requiredDVNCount > 0) {
+            for (uint8 i = 0; i < _config.requiredDVNCount; ++i) {
+                if (!_verified(_config.requiredDVNs[i], _headerHash, _payloadHash, _config.confirmations)) {
+                    // return if any of the required DVNs haven't signed
+                    return false;
+                }
+            }
+            if (_config.optionalDVNCount == 0) {
+                // returns early if all required DVNs have signed and there are no optional DVNs
+                return true;
+            }
+        }
+
+        // then it must require optional validations
+        uint8 threshold = _config.optionalDVNThreshold;
+        for (uint8 i = 0; i < _config.optionalDVNCount; ++i) {
+            if (_verified(_config.optionalDVNs[i], _headerHash, _payloadHash, _config.confirmations)) {
+                // increment the optional count if the optional DVN has signed
+                threshold--;
+                if (threshold == 0) {
+                    // early return if the optional threshold has hit
+                    return true;
+                }
+            }
+        }
+
+        // return false as a catch-all
+        return false;
+    }
+}

package/contracts/uln/SendUlnBase.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+
+import { ILayerZeroDVN } from "./interfaces/ILayerZeroDVN.sol";
+import { DVNOptions } from "./libs/DVNOptions.sol";
+import { UlnOptions } from "./libs/UlnOptions.sol";
+import { WorkerOptions } from "../SendLibBase.sol";
+import { UlnConfig, UlnBase } from "./UlnBase.sol";
+
+/// @dev includes the utility functions for checking ULN states and logics
+abstract contract SendUlnBase is UlnBase {
+    event DVNFeePaid(address[] requiredDVNs, address[] optionalDVNs, uint256[] fees);
+
+    function _splitUlnOptions(bytes calldata _options) internal pure returns (bytes memory, WorkerOptions[] memory) {
+        (bytes memory executorOpts, bytes memory dvnOpts) = UlnOptions.decode(_options);
+
+        if (dvnOpts.length == 0) {
+            return (executorOpts, new WorkerOptions[](0));
+        }
+
+        WorkerOptions[] memory workerOpts = new WorkerOptions[](1);
+        workerOpts[0] = WorkerOptions(DVNOptions.WORKER_ID, dvnOpts);
+        return (executorOpts, workerOpts);
+    }
+
+    /// ---------- pay and assign jobs ----------
+
+    function _payDVNs(
+        mapping(address => uint256) storage _fees,
+        Packet memory _packet,
+        WorkerOptions[] memory _options
+    ) internal returns (uint256 totalFee, bytes memory encodedPacket) {
+        bytes memory packetHeader = PacketV1Codec.encodePacketHeader(_packet);
+        bytes memory payload = PacketV1Codec.encodePayload(_packet);
+        bytes32 payloadHash = keccak256(payload);
+        uint32 dstEid = _packet.dstEid;
+        address sender = _packet.sender;
+        UlnConfig memory config = getUlnConfig(sender, dstEid);
+
+        // if options is not empty, it must be dvn options
+        bytes memory dvnOptions = _options.length == 0 ? bytes("") : _options[0].options;
+        uint256[] memory dvnFees;
+        (totalFee, dvnFees) = _assignJobs(
+            _fees,
+            config,
+            ILayerZeroDVN.AssignJobParam(dstEid, packetHeader, payloadHash, config.confirmations, sender),
+            dvnOptions
+        );
+        encodedPacket = abi.encodePacked(packetHeader, payload);
+
+        emit DVNFeePaid(config.requiredDVNs, config.optionalDVNs, dvnFees);
+    }
+
+    function _assignJobs(
+        mapping(address => uint256) storage _fees,
+        UlnConfig memory _ulnConfig,
+        ILayerZeroDVN.AssignJobParam memory _param,
+        bytes memory dvnOptions
+    ) internal returns (uint256 totalFee, uint256[] memory dvnFees) {
+        (bytes[] memory optionsArray, uint8[] memory dvnIds) = DVNOptions.groupDVNOptionsByIdx(dvnOptions);
+
+        uint8 dvnsLength = _ulnConfig.requiredDVNCount + _ulnConfig.optionalDVNCount;
+        dvnFees = new uint256[](dvnsLength);
+        for (uint8 i = 0; i < dvnsLength; ++i) {
+            address dvn = i < _ulnConfig.requiredDVNCount
+                ? _ulnConfig.requiredDVNs[i]
+                : _ulnConfig.optionalDVNs[i - _ulnConfig.requiredDVNCount];
+
+            bytes memory options = "";
+            for (uint256 j = 0; j < dvnIds.length; ++j) {
+                if (dvnIds[j] == i) {
+                    options = optionsArray[j];
+                    break;
+                }
+            }
+
+            dvnFees[i] = ILayerZeroDVN(dvn).assignJob(_param, options);
+            if (dvnFees[i] > 0) {
+                _fees[dvn] += dvnFees[i];
+                totalFee += dvnFees[i];
+            }
+        }
+    }
+
+    /// ---------- quote ----------
+    function _quoteDVNs(
+        address _sender,
+        uint32 _dstEid,
+        WorkerOptions[] memory _options
+    ) internal view returns (uint256 totalFee) {
+        UlnConfig memory config = getUlnConfig(_sender, _dstEid);
+
+        // if options is not empty, it must be dvn options
+        bytes memory dvnOptions = _options.length == 0 ? bytes("") : _options[0].options;
+        (bytes[] memory optionsArray, uint8[] memory dvnIndices) = DVNOptions.groupDVNOptionsByIdx(dvnOptions);
+
+        totalFee = _getFees(config, _dstEid, _sender, optionsArray, dvnIndices);
+    }
+
+    function _getFees(
+        UlnConfig memory _config,
+        uint32 _dstEid,
+        address _sender,
+        bytes[] memory _optionsArray,
+        uint8[] memory _dvnIds
+    ) internal view returns (uint256 totalFee) {
+        // here we merge 2 list of dvns into 1 to allocate the indexed dvn options to the right dvn
+        uint8 dvnsLength = _config.requiredDVNCount + _config.optionalDVNCount;
+        for (uint8 i = 0; i < dvnsLength; ++i) {
+            address dvn = i < _config.requiredDVNCount
+                ? _config.requiredDVNs[i]
+                : _config.optionalDVNs[i - _config.requiredDVNCount];
+
+            bytes memory options = "";
+            // it is a double loop here. however, if the list is short, the cost is very acceptable.
+            for (uint256 j = 0; j < _dvnIds.length; ++j) {
+                if (_dvnIds[j] == i) {
+                    options = _optionsArray[j];
+                    break;
+                }
+            }
+            totalFee += ILayerZeroDVN(dvn).getFee(_dstEid, _config.confirmations, _sender, options);
+        }
+    }
+}