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

package/contracts/SendLibBaseE2.sol

@@ -0,0 +1,140 @@
+// 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, MessagingFee } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { IMessageLib, MessageLibType } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLib.sol";
+import { ISendLib, Packet } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { SendLibBase, WorkerOptions, ExecutorConfig } from "./SendLibBase.sol";
+
+/// @dev send-side message library base contract on endpoint v2.
+/// design: the high level logic is the same as SendLibBaseE1
+/// 1/ with added interfaces
+/// 2/ adapt the functions to the new types, like uint32 for eid, address for sender.
+abstract contract SendLibBaseE2 is SendLibBase, ERC165, ISendLib {
+    event NativeFeeWithdrawn(address worker, address receiver, uint256 amount);
+    event LzTokenFeeWithdrawn(address lzToken, address receiver, uint256 amount);
+
+    error LZ_MessageLib_NotTreasury();
+    error LZ_MessageLib_CannotWithdrawAltToken();
+
+    constructor(
+        address _endpoint,
+        uint256 _treasuryGasLimit,
+        uint256 _treasuryNativeFeeCap
+    ) SendLibBase(_endpoint, ILayerZeroEndpointV2(_endpoint).eid(), _treasuryGasLimit, _treasuryNativeFeeCap) {}
+
+    function supportsInterface(bytes4 _interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+        return
+            _interfaceId == type(IMessageLib).interfaceId ||
+            _interfaceId == type(ISendLib).interfaceId ||
+            super.supportsInterface(_interfaceId);
+    }
+
+    // ========================= OnlyEndpoint =========================
+    // @dev this function is marked as virtual and public for testing purpose
+    function send(
+        Packet calldata _packet,
+        bytes calldata _options,
+        bool _payInLzToken
+    ) public virtual onlyEndpoint returns (MessagingFee memory, bytes memory) {
+        (bytes memory encodedPacket, uint256 totalNativeFee) = _payWorkers(_packet, _options);
+
+        (uint256 treasuryNativeFee, uint256 lzTokenFee) = _payTreasury(
+            _packet.sender,
+            _packet.dstEid,
+            totalNativeFee,
+            _payInLzToken
+        );
+        totalNativeFee += treasuryNativeFee;
+
+        return (MessagingFee(totalNativeFee, lzTokenFee), encodedPacket);
+    }
+
+    // ========================= OnlyOwner =========================
+    function setTreasury(address _treasury) external onlyOwner {
+        _setTreasury(_treasury);
+    }
+
+    // ========================= External =========================
+    /// @dev E2 only
+    function withdrawFee(address _to, uint256 _amount) external {
+        _debitFee(_amount);
+        address nativeToken = ILayerZeroEndpointV2(endpoint).nativeToken();
+        // transfers native if nativeToken == address(0x0)
+        Transfer.nativeOrToken(nativeToken, _to, _amount);
+        emit NativeFeeWithdrawn(msg.sender, _to, _amount);
+    }
+
+    /// @dev _lzToken is a user-supplied value because lzToken might change in the endpoint before all lzToken can be taken out
+    /// @dev E2 only
+    /// @dev treasury only function
+    function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external {
+        if (msg.sender != treasury) revert LZ_MessageLib_NotTreasury();
+
+        // lz token cannot be the same as the native token
+        if (ILayerZeroEndpointV2(endpoint).nativeToken() == _lzToken) revert LZ_MessageLib_CannotWithdrawAltToken();
+
+        Transfer.token(_lzToken, _to, _amount);
+
+        emit LzTokenFeeWithdrawn(_lzToken, _to, _amount);
+    }
+
+    // ========================= View =========================
+    function quote(
+        Packet calldata _packet,
+        bytes calldata _options,
+        bool _payInLzToken
+    ) external view returns (MessagingFee memory) {
+        (uint256 nativeFee, uint256 lzTokenFee) = _quote(
+            _packet.sender,
+            _packet.dstEid,
+            _packet.message.length,
+            _payInLzToken,
+            _options
+        );
+        return MessagingFee(nativeFee, lzTokenFee);
+    }
+
+    function messageLibType() external pure virtual override returns (MessageLibType) {
+        return MessageLibType.Send;
+    }
+
+    // ========================= Internal =========================
+    /// 1/ handle executor
+    /// 2/ handle other workers
+    function _payWorkers(
+        Packet calldata _packet,
+        bytes calldata _options
+    ) internal returns (bytes memory encodedPacket, uint256 totalNativeFee) {
+        // split workers options
+        (bytes memory executorOptions, WorkerOptions[] memory validationOptions) = _splitOptions(_options);
+
+        // handle executor
+        ExecutorConfig memory config = getExecutorConfig(_packet.sender, _packet.dstEid);
+        uint256 msgSize = _packet.message.length;
+        _assertMessageSize(msgSize, config.maxMessageSize);
+        totalNativeFee += _payExecutor(config.executor, _packet.dstEid, _packet.sender, msgSize, executorOptions);
+
+        // handle other workers
+        (uint256 verifierFee, bytes memory packetBytes) = _payVerifier(_packet, validationOptions); //for ULN, it will be dvns
+        totalNativeFee += verifierFee;
+
+        encodedPacket = packetBytes;
+    }
+
+    // ======================= Virtual =======================
+    // For implementation to override
+    function _payVerifier(
+        Packet calldata _packet,
+        WorkerOptions[] memory _options
+    ) internal virtual returns (uint256 otherWorkerFees, bytes memory encodedPacket);
+
+    // receive native token from endpoint
+    receive() external payable virtual {}
+}

package/contracts/SimpleReadExecutor.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+
+import { ILayerZeroReadExecutor } from "./interfaces/ILayerZeroReadExecutor.sol";
+import { ExecutorOptions } from "./libs/ExecutorOptions.sol";
+
+struct ExecutionParams {
+    address receiver;
+    Origin origin;
+    bytes32 guid;
+    bytes message;
+    bytes extraData;
+    uint256 gasLimit;
+}
+
+interface ILayerZeroEndpointV2 {
+    function eid() external view returns (uint32);
+
+    function lzReceive(
+        Origin calldata _origin,
+        address _receiver,
+        bytes32 _guid,
+        bytes calldata _message,
+        bytes calldata _extraData
+    ) external payable;
+
+    function lzReceiveAlert(
+        Origin calldata _origin,
+        address _receiver,
+        bytes32 _guid,
+        uint256 _gas,
+        uint256 _value,
+        bytes calldata _message,
+        bytes calldata _extraData,
+        bytes calldata _reason
+    ) external;
+}
+
+contract SimpleReadExecutor is ILayerZeroReadExecutor {
+    using ExecutorOptions for bytes;
+
+    address public immutable endpoint;
+
+    uint128 public gasPerByte;
+    uint128 public gasPrice;
+
+    constructor(address _endpoint) {
+        endpoint = _endpoint;
+    }
+
+    function configGas(uint128 _gasPerByte, uint128 _gasPrice) external {
+        gasPerByte = _gasPerByte;
+        gasPrice = _gasPrice;
+    }
+
+    function assignJob(address _sender, bytes calldata _options) external returns (uint256) {
+        return getFee(_sender, _options);
+    }
+
+    function execute(ExecutionParams calldata _executionParams) external payable {
+        try
+            ILayerZeroEndpointV2(endpoint).lzReceive{ value: msg.value, gas: _executionParams.gasLimit }(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.message,
+                _executionParams.extraData
+            )
+        {
+            // do nothing
+        } catch (bytes memory reason) {
+            ILayerZeroEndpointV2(endpoint).lzReceiveAlert(
+                _executionParams.origin,
+                _executionParams.receiver,
+                _executionParams.guid,
+                _executionParams.gasLimit,
+                msg.value,
+                _executionParams.message,
+                _executionParams.extraData,
+                reason
+            );
+        }
+    }
+
+    function mustExecute(ExecutionParams calldata _executionParams) external payable {
+        ILayerZeroEndpointV2(endpoint).lzReceive{ value: msg.value, gas: _executionParams.gasLimit }(
+            _executionParams.origin,
+            _executionParams.receiver,
+            _executionParams.guid,
+            _executionParams.message,
+            _executionParams.extraData
+        );
+    }
+
+    // ========================= View =========================
+
+    function getFee(address /*_sender*/, bytes calldata _options) public view returns (uint256) {
+        // For simplify, we only support one execute option, and must be LZREAD type
+        (uint8 optionType, bytes calldata option, ) = _options.nextExecutorOption(0);
+        require(optionType == ExecutorOptions.OPTION_TYPE_LZREAD, "SimpleReadExecutor: not LZREAD option");
+        (uint128 gas, uint32 calldataSize, uint128 value) = option.decodeLzReadOption();
+        // calculate fee
+        return (gas + calldataSize * gasPerByte) * gasPrice + value;
+    }
+
+    receive() external payable virtual {}
+}

package/contracts/Treasury.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { ILayerZeroTreasury } from "./interfaces/ILayerZeroTreasury.sol";
+
+contract Treasury is Ownable, ILayerZeroTreasury {
+    uint256 public nativeBP;
+    uint256 public lzTokenFee;
+    bool public lzTokenEnabled;
+
+    error LZ_Treasury_LzTokenNotEnabled();
+
+    function getFee(
+        address /*_sender*/,
+        uint32 /*_eid*/,
+        uint256 _totalFee,
+        bool _payInLzToken
+    ) external view override returns (uint256) {
+        return _getFee(_totalFee, _payInLzToken);
+    }
+
+    function payFee(
+        address /*_sender*/,
+        uint32 /*_eid*/,
+        uint256 _totalFee,
+        bool _payInLzToken
+    ) external payable override returns (uint256) {
+        return _getFee(_totalFee, _payInLzToken);
+    }
+
+    function setLzTokenEnabled(bool _lzTokenEnabled) external onlyOwner {
+        lzTokenEnabled = _lzTokenEnabled;
+    }
+
+    function setNativeFeeBP(uint256 _nativeBP) external onlyOwner {
+        nativeBP = _nativeBP;
+    }
+
+    function setLzTokenFee(uint256 _lzTokenFee) external onlyOwner {
+        lzTokenFee = _lzTokenFee;
+    }
+
+    function withdrawLzToken(address _messageLib, address _lzToken, address _to, uint256 _amount) external onlyOwner {
+        ISendLib(_messageLib).withdrawLzTokenFee(_lzToken, _to, _amount);
+    }
+
+    function withdrawNativeFee(address _messageLib, address payable _to, uint256 _amount) external onlyOwner {
+        ISendLib(_messageLib).withdrawFee(_to, _amount);
+    }
+
+    // this is for withdrawing lz token sent to this contract by uln301 and fee handler
+    // and to withdraw any native sent over via payFee
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyOwner {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+    }
+
+    // ======================= Internal =======================
+
+    function _getFee(uint256 _totalFee, bool _payInLzToken) internal view returns (uint256) {
+        if (_payInLzToken) {
+            if (!lzTokenEnabled) revert LZ_Treasury_LzTokenNotEnabled();
+            return lzTokenFee;
+        } else {
+            return (_totalFee * nativeBP) / 10000;
+        }
+    }
+}

package/contracts/Worker.sol

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Pausable } from "@openzeppelin/contracts/security/Pausable.sol";
+import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol";
+
+import { ISendLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { IWorker } from "./interfaces/IWorker.sol";
+
+abstract contract Worker is AccessControl, Pausable, IWorker {
+    bytes32 internal constant MESSAGE_LIB_ROLE = keccak256("MESSAGE_LIB_ROLE");
+    bytes32 internal constant ALLOWLIST = keccak256("ALLOWLIST");
+    bytes32 internal constant DENYLIST = keccak256("DENYLIST");
+    bytes32 internal constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+
+    address public workerFeeLib;
+
+    uint64 public allowlistSize;
+    uint16 public defaultMultiplierBps;
+    address public priceFeed;
+
+    mapping(uint32 eid => uint8[] optionTypes) internal supportedOptionTypes;
+
+    // ========================= Constructor =========================
+
+    /// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE
+    /// @param _priceFeed price feed address
+    /// @param _defaultMultiplierBps default multiplier for worker fee
+    /// @param _roleAdmin address that is granted the DEFAULT_ADMIN_ROLE (can grant and revoke all roles)
+    /// @param _admins array of admin addresses that are granted the ADMIN_ROLE
+    constructor(
+        address[] memory _messageLibs,
+        address _priceFeed,
+        uint16 _defaultMultiplierBps,
+        address _roleAdmin,
+        address[] memory _admins
+    ) {
+        defaultMultiplierBps = _defaultMultiplierBps;
+        priceFeed = _priceFeed;
+
+        if (_roleAdmin != address(0x0)) {
+            _grantRole(DEFAULT_ADMIN_ROLE, _roleAdmin); // _roleAdmin can grant and revoke all roles
+        }
+
+        for (uint256 i = 0; i < _messageLibs.length; ++i) {
+            _grantRole(MESSAGE_LIB_ROLE, _messageLibs[i]);
+        }
+
+        for (uint256 i = 0; i < _admins.length; ++i) {
+            _grantRole(ADMIN_ROLE, _admins[i]);
+        }
+    }
+
+    // ========================= Modifier =========================
+
+    modifier onlyAcl(address _sender) {
+        if (!hasAcl(_sender)) {
+            revert Worker_NotAllowed();
+        }
+        _;
+    }
+
+    /// @dev Access control list using allowlist and denylist
+    /// @dev 1) if one address is in the denylist -> deny
+    /// @dev 2) else if address in the allowlist OR allowlist is empty (allows everyone)-> allow
+    /// @dev 3) else deny
+    /// @param _sender address to check
+    function hasAcl(address _sender) public view returns (bool) {
+        if (hasRole(DENYLIST, _sender)) {
+            return false;
+        } else if (allowlistSize == 0 || hasRole(ALLOWLIST, _sender)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    // ========================= OnyDefaultAdmin =========================
+
+    /// @dev flag to pause execution of workers (if used with whenNotPaused modifier)
+    /// @param _paused true to pause, false to unpause
+    function setPaused(bool _paused) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        if (_paused) {
+            _pause();
+        } else {
+            _unpause();
+        }
+    }
+
+    // ========================= OnlyAdmin =========================
+
+    /// @param _priceFeed price feed address
+    function setPriceFeed(address _priceFeed) external onlyRole(ADMIN_ROLE) {
+        priceFeed = _priceFeed;
+        emit SetPriceFeed(_priceFeed);
+    }
+
+    /// @param _workerFeeLib worker fee lib address
+    function setWorkerFeeLib(address _workerFeeLib) external onlyRole(ADMIN_ROLE) {
+        workerFeeLib = _workerFeeLib;
+        emit SetWorkerLib(_workerFeeLib);
+    }
+
+    /// @param _multiplierBps default multiplier for worker fee
+    function setDefaultMultiplierBps(uint16 _multiplierBps) external onlyRole(ADMIN_ROLE) {
+        defaultMultiplierBps = _multiplierBps;
+        emit SetDefaultMultiplierBps(_multiplierBps);
+    }
+
+    /// @dev supports withdrawing fee from ULN301, ULN302 and more
+    /// @param _lib message lib address
+    /// @param _to address to withdraw fee to
+    /// @param _amount amount to withdraw
+    function withdrawFee(address _lib, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
+        if (!hasRole(MESSAGE_LIB_ROLE, _lib)) revert Worker_OnlyMessageLib();
+        ISendLib(_lib).withdrawFee(_to, _amount);
+        emit Withdraw(_lib, _to, _amount);
+    }
+
+    /// @dev supports withdrawing token from the contract
+    /// @param _token token address
+    /// @param _to address to withdraw token to
+    /// @param _amount amount to withdraw
+    function withdrawToken(address _token, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {
+        // transfers native if _token is address(0x0)
+        Transfer.nativeOrToken(_token, _to, _amount);
+    }
+
+    function setSupportedOptionTypes(uint32 _eid, uint8[] calldata _optionTypes) external onlyRole(ADMIN_ROLE) {
+        supportedOptionTypes[_eid] = _optionTypes;
+    }
+
+    // ========================= View Functions =========================
+    function getSupportedOptionTypes(uint32 _eid) external view returns (uint8[] memory) {
+        return supportedOptionTypes[_eid];
+    }
+
+    // ========================= Internal Functions =========================
+
+    /// @dev overrides AccessControl to allow for counting of allowlistSize
+    /// @param _role role to grant
+    /// @param _account address to grant role to
+    function _grantRole(bytes32 _role, address _account) internal override {
+        if (_role == ALLOWLIST && !hasRole(_role, _account)) {
+            ++allowlistSize;
+        }
+        super._grantRole(_role, _account);
+    }
+
+    /// @dev overrides AccessControl to allow for counting of allowlistSize
+    /// @param _role role to revoke
+    /// @param _account address to revoke role from
+    function _revokeRole(bytes32 _role, address _account) internal override {
+        if (_role == ALLOWLIST && hasRole(_role, _account)) {
+            --allowlistSize;
+        }
+        super._revokeRole(_role, _account);
+    }
+
+    /// @dev overrides AccessControl to disable renouncing of roles
+    function renounceRole(bytes32 /*role*/, address /*account*/) public pure override {
+        revert Worker_RoleRenouncingDisabled();
+    }
+}

package/contracts/decompressor/DVNDecoder.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import { ExecuteParam } from "../uln/dvn/DVN.sol";
+
+library DVNDecoder {
+    uint8 internal constant DVN_INDEX_SIZE = 2; // uint16
+    uint8 internal constant PARAMS_LENGTH_SIZE = 1; // uint8
+    uint8 internal constant TARGET_INDEX_SIZE = 1; // uint8
+    uint8 internal constant EXPIRATION_SIZE = 16; // uint128
+    uint8 internal constant SIGNATURES_LENGTH_SIZE = 2; // uint16
+    uint8 internal constant CALL_DATA_LENGTH_SIZE = 8; // uint64
+
+    function execute(
+        bytes calldata _encoded,
+        uint32 _vid,
+        mapping(uint8 index => address target) storage _targets
+    ) internal view returns (uint16 dvnIndex, ExecuteParam[] memory params) {
+        uint256 cursor = 0;
+
+        dvnIndex = uint16(bytes2(_encoded[cursor:cursor + DVN_INDEX_SIZE]));
+        cursor += DVN_INDEX_SIZE;
+
+        uint8 length = uint8(bytes1(_encoded[cursor:cursor + PARAMS_LENGTH_SIZE]));
+        cursor += PARAMS_LENGTH_SIZE;
+
+        params = new ExecuteParam[](length);
+
+        for (uint256 i = 0; i < length; i++) {
+            uint8 targetIndex = uint8(bytes1(_encoded[cursor:cursor + TARGET_INDEX_SIZE]));
+            cursor += TARGET_INDEX_SIZE;
+
+            uint128 expiration = uint128(bytes16(_encoded[cursor:cursor + EXPIRATION_SIZE]));
+            cursor += EXPIRATION_SIZE;
+
+            uint16 signaturesLength = uint16(bytes2(_encoded[cursor:cursor + SIGNATURES_LENGTH_SIZE]));
+            cursor += SIGNATURES_LENGTH_SIZE;
+
+            bytes memory signatures = _encoded[cursor:cursor + signaturesLength];
+            cursor += signaturesLength;
+
+            uint64 callDataLength = uint64(bytes8(_encoded[cursor:cursor + CALL_DATA_LENGTH_SIZE]));
+            cursor += CALL_DATA_LENGTH_SIZE;
+
+            bytes memory callData = _encoded[cursor:cursor + callDataLength];
+            cursor += callDataLength;
+
+            params[i] = ExecuteParam(_vid, _targets[targetIndex], callData, expiration, signatures);
+        }
+    }
+}

package/contracts/decompressor/DVNDecompressor.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { DVN, ExecuteParam } from "../uln/dvn/DVN.sol";
+import { DVNDecoder } from "./DVNDecoder.sol";
+import { DecompressorExtension } from "./DecompressorExtension.sol";
+
+struct TargetParam {
+    uint8 idx;
+    address addr;
+}
+
+struct DVNParam {
+    uint16 idx;
+    address addr;
+}
+
+contract DVNDecompressor is Ownable, DecompressorExtension {
+    uint32 public immutable vid;
+
+    mapping(uint16 index => address dvn) public dvns;
+    mapping(uint8 index => address target) public targets;
+
+    constructor(uint32 _vid, DVNParam[] memory _dvns, TargetParam[] memory _targets) {
+        vid = _vid;
+
+        for (uint256 i = 0; i < _dvns.length; i++) {
+            DVNParam memory param = _dvns[i];
+            dvns[param.idx] = param.addr;
+        }
+
+        for (uint256 i = 0; i < _targets.length; i++) {
+            TargetParam memory param = _targets[i];
+            targets[param.idx] = param.addr;
+        }
+    }
+
+    function addTargets(TargetParam[] memory _targets) external onlyOwner {
+        for (uint256 i = 0; i < _targets.length; i++) {
+            targets[_targets[i].idx] = _targets[i].addr;
+        }
+    }
+
+    function removeTargets(uint8[] memory _idx) external onlyOwner {
+        for (uint256 i = 0; i < _idx.length; i++) {
+            delete targets[_idx[i]];
+        }
+    }
+
+    function addDVNs(DVNParam[] memory _dvns) external onlyOwner {
+        for (uint256 i = 0; i < _dvns.length; i++) {
+            dvns[_dvns[i].idx] = _dvns[i].addr;
+        }
+    }
+
+    function removeDVNs(uint16[] memory _idx) external onlyOwner {
+        for (uint256 i = 0; i < _idx.length; i++) {
+            delete dvns[_idx[i]];
+        }
+    }
+
+    function execute(bytes calldata _encoded) external onlyOwner {
+        (uint16 dvnIndex, ExecuteParam[] memory params) = DVNDecoder.execute(_encoded, vid, targets);
+
+        DVN(dvns[dvnIndex]).execute(params);
+    }
+}