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

package/contracts/libs/ExecutorOptions.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/CalldataBytesLib.sol";
+
+library ExecutorOptions {
+    using CalldataBytesLib for bytes;
+
+    uint8 internal constant WORKER_ID = 1;
+
+    uint8 internal constant OPTION_TYPE_LZRECEIVE = 1;
+    uint8 internal constant OPTION_TYPE_NATIVE_DROP = 2;
+    uint8 internal constant OPTION_TYPE_LZCOMPOSE = 3;
+    uint8 internal constant OPTION_TYPE_ORDERED_EXECUTION = 4;
+    uint8 internal constant OPTION_TYPE_LZREAD = 5;
+
+    error Executor_InvalidLzReceiveOption();
+    error Executor_InvalidNativeDropOption();
+    error Executor_InvalidLzComposeOption();
+    error Executor_InvalidLzReadOption();
+
+    /// @dev decode the next executor option from the options starting from the specified cursor
+    /// @param _options [executor_id][executor_option][executor_id][executor_option]...
+    ///        executor_option = [option_size][option_type][option]
+    ///        option_size = len(option_type) + len(option)
+    ///        executor_id: uint8, option_size: uint16, option_type: uint8, option: bytes
+    /// @param _cursor the cursor to start decoding from
+    /// @return optionType the type of the option
+    /// @return option the option of the executor
+    /// @return cursor the cursor to start decoding the next executor option
+    function nextExecutorOption(
+        bytes calldata _options,
+        uint256 _cursor
+    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
+        unchecked {
+            // skip worker id
+            cursor = _cursor + 1;
+
+            // read option size
+            uint16 size = _options.toU16(cursor);
+            cursor += 2;
+
+            // read option type
+            optionType = _options.toU8(cursor);
+
+            // startCursor and endCursor are used to slice the option from _options
+            uint256 startCursor = cursor + 1; // skip option type
+            uint256 endCursor = cursor + size;
+            option = _options[startCursor:endCursor];
+            cursor += size;
+        }
+    }
+
+    function decodeLzReceiveOption(bytes calldata _option) internal pure returns (uint128 gas, uint128 value) {
+        if (_option.length != 16 && _option.length != 32) revert Executor_InvalidLzReceiveOption();
+        gas = _option.toU128(0);
+        value = _option.length == 32 ? _option.toU128(16) : 0;
+    }
+
+    function decodeNativeDropOption(bytes calldata _option) internal pure returns (uint128 amount, bytes32 receiver) {
+        if (_option.length != 48) revert Executor_InvalidNativeDropOption();
+        amount = _option.toU128(0);
+        receiver = _option.toB32(16);
+    }
+
+    function decodeLzComposeOption(
+        bytes calldata _option
+    ) internal pure returns (uint16 index, uint128 gas, uint128 value) {
+        if (_option.length != 18 && _option.length != 34) revert Executor_InvalidLzComposeOption();
+        index = _option.toU16(0);
+        gas = _option.toU128(2);
+        value = _option.length == 34 ? _option.toU128(18) : 0;
+    }
+
+    function decodeLzReadOption(
+        bytes calldata _option
+    ) internal pure returns (uint128 gas, uint32 calldataSize, uint128 value) {
+        if (_option.length != 20 && _option.length != 36) revert Executor_InvalidLzReadOption();
+        gas = _option.toU128(0);
+        calldataSize = _option.toU32(16);
+        value = _option.length == 36 ? _option.toU128(20) : 0;
+    }
+
+    function encodeLzReceiveOption(uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
+        return _value == 0 ? abi.encodePacked(_gas) : abi.encodePacked(_gas, _value);
+    }
+
+    function encodeNativeDropOption(uint128 _amount, bytes32 _receiver) internal pure returns (bytes memory) {
+        return abi.encodePacked(_amount, _receiver);
+    }
+
+    function encodeLzComposeOption(uint16 _index, uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
+        return _value == 0 ? abi.encodePacked(_index, _gas) : abi.encodePacked(_index, _gas, _value);
+    }
+
+    function encodeLzReadOption(
+        uint128 _gas,
+        uint32 _calldataSize,
+        uint128 _value
+    ) internal pure returns (bytes memory) {
+        return _value == 0 ? abi.encodePacked(_gas, _calldataSize) : abi.encodePacked(_gas, _calldataSize, _value);
+    }
+}

package/contracts/libs/SafeCall.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+pragma solidity ^0.8.20;
+
+/// @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/lowlat/EssenceDVNWrapper.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { AccessControl } from "@openzeppelin/contracts/access/AccessControl.sol";
+
+import { MultiCall } from "./MultiCall.sol";
+
+/// @title EssenceDVNWrapper is a contract, used to execute multiple worker calls in a single transaction
+/// The calls should be as follows:
+/// 1. N calls to dvn.execute() to verify the payload on ULN
+/// 2. 1 call to uln.commitVerification() to commit the verification into the endpoint
+/// 3. 1 call to executor.execute() to execute lzReceive() on the endpoint
+///
+/// Node: The DVN should assign EssenceDVNWrapper as an admin to the DVN contract.
+///
+contract EssenceDVNWrapper is AccessControl, MultiCall {
+    bytes32 internal constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+
+    error DVNWrapper_InvalidRole(bytes32 role);
+    error DVNWrapper_InvalidAdminCount();
+    error DVNWrapper_RoleRenouncingDisabled();
+
+    uint256 public adminCount;
+
+    modifier onlyAdmin(bytes32 _role) {
+        if (_role == ADMIN_ROLE) {
+            _checkRole(_role); // admin required
+        } else {
+            revert DVNWrapper_InvalidRole(_role);
+        }
+        _;
+    }
+
+    constructor(address[] memory admins) {
+        if (admins.length == 0) {
+            revert DVNWrapper_InvalidAdminCount();
+        }
+        for (uint i = 0; i < admins.length; i++) {
+            _setupRole(ADMIN_ROLE, admins[i]);
+        }
+        adminCount = admins.length;
+    }
+
+    function multiCall(
+        Call[] calldata _calls
+    ) public payable override onlyAdmin(ADMIN_ROLE) returns (bool[] memory successes, bytes[] memory results) {
+        (successes, results) = super.multiCall(_calls);
+    }
+
+    // ========================= Override Functions =========================
+
+    function grantRole(bytes32 _role, address _account) public override onlyAdmin(_role) {
+        _grantRole(_role, _account);
+    }
+
+    function revokeRole(bytes32 _role, address _account) public override onlyAdmin(_role) {
+        _revokeRole(_role, _account);
+    }
+
+    function renounceRole(bytes32 /*role*/, address /*account*/) public pure override {
+        revert DVNWrapper_RoleRenouncingDisabled();
+    }
+
+    function _grantRole(bytes32 _role, address _account) internal override {
+        if (_role == ADMIN_ROLE) ++adminCount;
+        super._grantRole(_role, _account);
+    }
+
+    function _revokeRole(bytes32 _role, address _account) internal override {
+        if (_role == ADMIN_ROLE) --adminCount;
+        if (adminCount == 0) {
+            revert DVNWrapper_InvalidAdminCount(); // not allowed to remove all admins
+        }
+        super._revokeRole(_role, _account);
+    }
+}

package/contracts/lowlat/MultiCall.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+contract MultiCall {
+    struct Call {
+        address target;
+        bytes data;
+        uint256 gasLimit;
+        uint256 value;
+        bool revertOnError;
+    }
+
+    error NotEnoughGas(uint256 index, uint256 requested, uint256 available);
+    error CallReverted(uint256 index, bytes result);
+
+    function multiCall(
+        Call[] calldata _calls
+    ) public payable virtual returns (bool[] memory successes, bytes[] memory results) {
+        successes = new bool[](_calls.length);
+        results = new bytes[](_calls.length);
+
+        for (uint256 i = 0; i < _calls.length; i++) {
+            Call calldata call = _calls[i];
+
+            if (gasleft() < call.gasLimit) revert NotEnoughGas(i, call.gasLimit, gasleft());
+
+            (successes[i], results[i]) = call.target.call{
+                value: call.value,
+                gas: call.gasLimit == 0 ? gasleft() : call.gasLimit
+            }(call.data);
+
+            if (!successes[i] && _calls[i].revertOnError) revert CallReverted(i, results[i]);
+        }
+
+        if (address(this).balance > 0) {
+            Transfer.native(msg.sender, address(this).balance);
+        }
+    }
+}

package/contracts/mocks/DVNMock.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.22;
+
+import { ExecuteParam } from "../uln/dvn/DVN.sol";
+
+contract DVNMock {
+    event Executed(uint32 vid, address target, bytes callData, uint256 expiration, bytes signatures);
+
+    uint32 public immutable vid;
+
+    constructor(uint32 _vid) {
+        vid = _vid;
+    }
+
+    function execute(ExecuteParam[] calldata _params) external {
+        for (uint256 i = 0; i < _params.length; i++) {
+            emit Executed(
+                _params[i].vid,
+                _params[i].target,
+                _params[i].callData,
+                _params[i].expiration,
+                _params[i].signatures
+            );
+        }
+    }
+
+    function verify(bytes calldata _packetHeader, bytes32 _payloadHash, uint64 _confirmations) external {}
+}

package/contracts/mocks/ExecutorMock.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.20;
+
+import { Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { PacketV1Codec } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol";
+import { IExecutor } from "../../contracts/interfaces/IExecutor.sol";
+
+contract ExecutorMock {
+    using PacketV1Codec for bytes;
+
+    event NativeDropMeta(
+        uint32 srcEid,
+        bytes32 sender,
+        uint64 nonce,
+        uint32 dstEid,
+        address oapp,
+        uint256 nativeDropGasLimit
+    );
+    event NativeDropped(address receiver, uint256 amount);
+    event Executed301(bytes packet, uint256 gasLimit);
+    event Executed302(
+        uint32 srcEid,
+        bytes32 sender,
+        uint64 nonce,
+        address receiver,
+        bytes32 guid,
+        bytes message,
+        bytes extraData,
+        uint256 gasLimit
+    );
+
+    uint32 public immutable dstEid;
+
+    constructor(uint32 _dstEid) {
+        dstEid = _dstEid;
+    }
+
+    function nativeDrop(
+        Origin calldata _origin,
+        uint32 _dstEid,
+        address _oapp,
+        IExecutor.NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit
+    ) external payable {
+        _nativeDrop(_origin, _dstEid, _oapp, _nativeDropParams, _nativeDropGasLimit);
+    }
+
+    function nativeDropAndExecute301(
+        Origin calldata _origin,
+        IExecutor.NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit,
+        bytes calldata _packet,
+        uint256 _gasLimit
+    ) external payable {
+        _nativeDrop(_origin, _packet.dstEid(), _packet.receiverB20(), _nativeDropParams, _nativeDropGasLimit);
+        emit Executed301(_packet, _gasLimit);
+    }
+
+    function execute301(bytes calldata _packet, uint256 _gasLimit) external {
+        emit Executed301(_packet, _gasLimit);
+    }
+
+    function nativeDropAndExecute302(
+        IExecutor.NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit,
+        IExecutor.ExecutionParams calldata _executionParams
+    ) external payable {
+        _nativeDrop(_executionParams.origin, dstEid, _executionParams.receiver, _nativeDropParams, _nativeDropGasLimit);
+
+        emit Executed302(
+            _executionParams.origin.srcEid,
+            _executionParams.origin.sender,
+            _executionParams.origin.nonce,
+            _executionParams.receiver,
+            _executionParams.guid,
+            _executionParams.message,
+            _executionParams.extraData,
+            _executionParams.gasLimit
+        );
+    }
+
+    function _nativeDrop(
+        Origin calldata _origin,
+        uint32 _dstEid,
+        address _oapp,
+        IExecutor.NativeDropParams[] calldata _nativeDropParams,
+        uint256 _nativeDropGasLimit
+    ) internal {
+        for (uint256 i = 0; i < _nativeDropParams.length; i++) {
+            emit NativeDropped(_nativeDropParams[i].receiver, _nativeDropParams[i].amount);
+        }
+        emit NativeDropMeta(_origin.srcEid, _origin.sender, _origin.nonce, _dstEid, _oapp, _nativeDropGasLimit);
+    }
+}

package/contracts/uln/LzExecutor.sol

@@ -0,0 +1,129 @@
+// 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 { IReceiveUlnE2 } from "./interfaces/IReceiveUlnE2.sol";
+import { ILayerZeroEndpointV2, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
+import { Transfer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol";
+
+import { ExecutionState, EndpointV2ViewUpgradeable } from "@layerzerolabs/lz-evm-protocol-v2/contracts/EndpointV2ViewUpgradeable.sol";
+
+import { VerificationState } from "./uln302/ReceiveUln302View.sol";
+
+struct LzReceiveParam {
+    Origin origin;
+    address receiver;
+    bytes32 guid;
+    bytes message;
+    bytes extraData;
+    uint256 gas;
+    uint256 value;
+}
+
+struct NativeDropParam {
+    address _receiver;
+    uint256 _amount;
+}
+
+interface IReceiveUlnView {
+    function verifiable(bytes calldata _packetHeader, bytes32 _payloadHash) external view returns (VerificationState);
+}
+
+contract LzExecutor is OwnableUpgradeable, EndpointV2ViewUpgradeable, Proxied {
+    error LzExecutor_Executed();
+    error LzExecutor_Verifying();
+    error LzExecutor_ReceiveLibViewNotSet();
+
+    event NativeWithdrawn(address _to, uint256 _amount);
+    event ReceiveLibViewSet(address _receiveLib, address _receiveLibView);
+
+    address public receiveUln302;
+    uint32 public localEid;
+
+    mapping(address receiveLib => address receiveLibView) public receiveLibToView;
+
+    function initialize(
+        address _receiveUln302,
+        address _receiveUln302View,
+        address _endpoint
+    ) external proxied initializer {
+        __Ownable_init();
+        __EndpointV2View_init(_endpoint);
+
+        receiveUln302 = _receiveUln302;
+        localEid = endpoint.eid();
+        receiveLibToView[_receiveUln302] = _receiveUln302View;
+    }
+
+    // ============================ OnlyOwner ===================================
+
+    function withdrawNative(address _to, uint256 _amount) external onlyOwner {
+        Transfer.native(_to, _amount);
+        emit NativeWithdrawn(_to, _amount);
+    }
+
+    function setReceiveLibView(address _receiveLib, address _receiveLibView) external onlyOwner {
+        receiveLibToView[_receiveLib] = _receiveLibView;
+        emit ReceiveLibViewSet(_receiveLib, _receiveLibView);
+    }
+
+    // ============================ External ===================================
+
+    /// @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 _nativeDropParams
+    ) external payable {
+        /// 1. check if executable, revert if executed
+        ExecutionState executionState = executable(_lzReceiveParam.origin, _lzReceiveParam.receiver);
+        if (executionState == ExecutionState.Executed) revert LzExecutor_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));
+
+            address receiveLibView = receiveLibToView[receiveLib];
+            if (receiveLibView == address(0x0)) revert LzExecutor_ReceiveLibViewNotSet();
+
+            VerificationState verificationState = IReceiveUlnView(receiveLibView).verifiable(packetHeader, payloadHash);
+            if (verificationState == VerificationState.Verifiable) {
+                // verification required
+                IReceiveUlnE2(receiveLib).commitVerification(packetHeader, payloadHash);
+            } else if (verificationState == VerificationState.Verifying) {
+                revert LzExecutor_Verifying();
+            }
+        }
+
+        /// 3. native drop
+        for (uint256 i = 0; i < _nativeDropParams.length; i++) {
+            NativeDropParam calldata param = _nativeDropParams[i];
+            Transfer.native(param._receiver, param._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
+        );
+    }
+}