@layerzerolabs/lz-evm-protocol-v2 2.0.2

package/contracts/messagelib/SimpleMessageLib.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity 0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+import { IMessageLib, MessageLibType } from "../interfaces/IMessageLib.sol";
+import { Packet } from "../interfaces/ISendLib.sol";
+import { ILayerZeroEndpointV2, MessagingFee, Origin } from "../interfaces/ILayerZeroEndpointV2.sol";
+import { Errors } from "../libs/Errors.sol";
+import { PacketV1Codec } from "./libs/PacketV1Codec.sol";
+import { Transfer } from "../libs/Transfer.sol";
+
+contract SimpleMessageLib is Ownable, ERC165 {
+    using SafeERC20 for IERC20;
+    using PacketV1Codec for bytes;
+
+    address public immutable endpoint;
+    address public immutable treasury;
+    uint32 public immutable localEid;
+    uint8 public constant PACKET_VERSION = 1;
+
+    address public whitelistCaller;
+
+    uint256 public lzTokenFee;
+    uint256 public nativeFee;
+
+    bytes public defaultOption;
+
+    error OnlyEndpoint();
+    error OnlyWhitelistCaller();
+    error InvalidEndpoint(address expected, address actual);
+    error ToIsAddressZero();
+    error LzTokenIsAddressZero();
+    error TransferFailed();
+
+    // only the endpoint can call SEND() and setConfig()
+    modifier onlyEndpoint() {
+        if (endpoint != msg.sender) {
+            revert OnlyEndpoint();
+        }
+        _;
+    }
+
+    constructor(address _endpoint, address _treasury) {
+        endpoint = _endpoint;
+        treasury = _treasury;
+        localEid = ILayerZeroEndpointV2(_endpoint).eid();
+        lzTokenFee = 99;
+        nativeFee = 100;
+        //        defaultOption = Options.encodeLegacyOptionsType1(200000);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return interfaceId == type(IMessageLib).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    // no validation logic at all
+    function validatePacket(bytes calldata packetBytes) external {
+        if (whitelistCaller != address(0x0) && msg.sender != whitelistCaller) {
+            revert OnlyWhitelistCaller();
+        }
+        Origin memory origin = Origin(packetBytes.srcEid(), packetBytes.sender(), packetBytes.nonce());
+        ILayerZeroEndpointV2(endpoint).verify(origin, packetBytes.receiverB20(), keccak256(packetBytes.payload()));
+    }
+
+    // ------------------ onlyEndpoint ------------------
+    function send(
+        Packet calldata _packet,
+        bytes memory _options,
+        bool _payInLzToken
+    ) external onlyEndpoint returns (MessagingFee memory fee, bytes memory encodedPacket, bytes memory options) {
+        encodedPacket = PacketV1Codec.encode(_packet);
+
+        options = _options.length == 0 ? defaultOption : _options;
+        _handleMessagingParamsHook(encodedPacket, options);
+
+        fee = MessagingFee(nativeFee, _payInLzToken ? lzTokenFee : 0);
+    }
+
+    // ------------------ onlyOwner ------------------
+    function setDefaultOption(bytes memory _defaultOption) external onlyOwner {
+        defaultOption = _defaultOption;
+    }
+
+    function setMessagingFee(uint256 _nativeFee, uint256 _lzTokenFee) external onlyOwner {
+        nativeFee = _nativeFee;
+        lzTokenFee = _lzTokenFee;
+    }
+
+    function setWhitelistCaller(address _whitelistCaller) external onlyOwner {
+        whitelistCaller = _whitelistCaller;
+    }
+
+    function withdrawFee(address _to, uint256 _amount) external onlyOwner {
+        if (_to == address(0x0)) {
+            revert ToIsAddressZero();
+        }
+
+        address altTokenAddr = ILayerZeroEndpointV2(endpoint).nativeToken();
+
+        // transfers native if altTokenAddr == address(0x0)
+        Transfer.nativeOrToken(altTokenAddr, _to, _amount);
+    }
+
+    function withdrawLzTokenFee(address _to, uint256 _amount) external onlyOwner {
+        if (_to == address(0x0)) {
+            revert ToIsAddressZero();
+        }
+        address lzToken = ILayerZeroEndpointV2(endpoint).lzToken();
+        if (lzToken == address(0x0)) {
+            revert LzTokenIsAddressZero();
+        }
+        IERC20(lzToken).safeTransfer(_to, _amount);
+    }
+
+    // ------------------ View ------------------
+    function quote(
+        Packet calldata /*_packet*/,
+        bytes calldata /*_options*/,
+        bool _payInLzToken
+    ) external view returns (MessagingFee memory) {
+        return MessagingFee(nativeFee, _payInLzToken ? lzTokenFee : 0);
+    }
+
+    function isSupportedEid(uint32) external pure returns (bool) {
+        return true;
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (0, 0, 2);
+    }
+
+    function messageLibType() external pure returns (MessageLibType) {
+        return MessageLibType.SendAndReceive;
+    }
+
+    // ------------------ Internal ------------------
+    function _handleMessagingParamsHook(bytes memory _encodedPacket, bytes memory _options) internal virtual {}
+
+    fallback() external payable {
+        revert Errors.NotImplemented();
+    }
+
+    receive() external payable {}
+}

package/contracts/messagelib/libs/BitMaps.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+// modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/BitMaps.sol
+pragma solidity ^0.8.22;
+
+type BitMap256 is uint256;
+
+using BitMaps for BitMap256 global;
+
+library BitMaps {
+    /**
+     * @dev Returns whether the bit at `index` is set.
+     */
+    function get(BitMap256 bitmap, uint8 index) internal pure returns (bool) {
+        uint256 mask = 1 << index;
+        return BitMap256.unwrap(bitmap) & mask != 0;
+    }
+
+    /**
+     * @dev Sets the bit at `index`.
+     */
+    function set(BitMap256 bitmap, uint8 index) internal pure returns (BitMap256) {
+        uint256 mask = 1 << index;
+        return BitMap256.wrap(BitMap256.unwrap(bitmap) | mask);
+    }
+}

package/contracts/messagelib/libs/ExecutorOptions.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { CalldataBytesLib } from "../../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;
+
+    error InvalidLzReceiveOption();
+    error InvalidNativeDropOption();
+    error InvalidLzComposeOption();
+
+    /// @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 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 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 InvalidLzComposeOption();
+        index = _option.toU16(0);
+        gas = _option.toU128(2);
+        value = _option.length == 34 ? _option.toU128(18) : 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);
+    }
+}

package/contracts/messagelib/libs/PacketV1Codec.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { Packet } from "../../interfaces/ISendLib.sol";
+import { AddressCast } from "../../libs/AddressCast.sol";
+
+library PacketV1Codec {
+    using AddressCast for address;
+    using AddressCast for bytes32;
+
+    uint8 internal constant PACKET_VERSION = 1;
+
+    // header (version + nonce + path)
+    // version
+    uint256 private constant PACKET_VERSION_OFFSET = 0;
+    //    nonce
+    uint256 private constant NONCE_OFFSET = 1;
+    //    path
+    uint256 private constant SRC_EID_OFFSET = 9;
+    uint256 private constant SENDER_OFFSET = 13;
+    uint256 private constant DST_EID_OFFSET = 45;
+    uint256 private constant RECEIVER_OFFSET = 49;
+    // payload (guid + message)
+    uint256 private constant GUID_OFFSET = 81; // keccak256(nonce + path)
+    uint256 private constant MESSAGE_OFFSET = 113;
+
+    function encode(Packet memory _packet) internal pure returns (bytes memory encodedPacket) {
+        encodedPacket = abi.encodePacked(
+            PACKET_VERSION,
+            _packet.nonce,
+            _packet.srcEid,
+            _packet.sender.toBytes32(),
+            _packet.dstEid,
+            _packet.receiver,
+            _packet.guid,
+            _packet.message
+        );
+    }
+
+    function encodePacketHeader(Packet memory _packet) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                PACKET_VERSION,
+                _packet.nonce,
+                _packet.srcEid,
+                _packet.sender.toBytes32(),
+                _packet.dstEid,
+                _packet.receiver
+            );
+    }
+
+    function encodePayload(Packet memory _packet) internal pure returns (bytes memory) {
+        return abi.encodePacked(_packet.guid, _packet.message);
+    }
+
+    function header(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return _packet[0:GUID_OFFSET];
+    }
+
+    function version(bytes calldata _packet) internal pure returns (uint8) {
+        return uint8(bytes1(_packet[PACKET_VERSION_OFFSET:NONCE_OFFSET]));
+    }
+
+    function nonce(bytes calldata _packet) internal pure returns (uint64) {
+        return uint64(bytes8(_packet[NONCE_OFFSET:SRC_EID_OFFSET]));
+    }
+
+    function srcEid(bytes calldata _packet) internal pure returns (uint32) {
+        return uint32(bytes4(_packet[SRC_EID_OFFSET:SENDER_OFFSET]));
+    }
+
+    function sender(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[SENDER_OFFSET:DST_EID_OFFSET]);
+    }
+
+    function senderAddressB20(bytes calldata _packet) internal pure returns (address) {
+        return sender(_packet).toAddress();
+    }
+
+    function dstEid(bytes calldata _packet) internal pure returns (uint32) {
+        return uint32(bytes4(_packet[DST_EID_OFFSET:RECEIVER_OFFSET]));
+    }
+
+    function receiver(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[RECEIVER_OFFSET:GUID_OFFSET]);
+    }
+
+    function receiverB20(bytes calldata _packet) internal pure returns (address) {
+        return receiver(_packet).toAddress();
+    }
+
+    function guid(bytes calldata _packet) internal pure returns (bytes32) {
+        return bytes32(_packet[GUID_OFFSET:MESSAGE_OFFSET]);
+    }
+
+    function message(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return bytes(_packet[MESSAGE_OFFSET:]);
+    }
+
+    function payload(bytes calldata _packet) internal pure returns (bytes calldata) {
+        return bytes(_packet[GUID_OFFSET:]);
+    }
+
+    function payloadHash(bytes calldata _packet) internal pure returns (bytes32) {
+        return keccak256(payload(_packet));
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@layerzerolabs/lz-evm-protocol-v2",
+  "version": "2.0.2",
+  "license": "LZBL-1.2",
+  "files": [
+    "artifacts/contracts/**/!(*.dbg).json",
+    "contracts/**/*"
+  ],
+  "scripts": {
+    "postpack": "node ./scripts/pack.mjs --postpack"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@openzeppelin/contracts": "^4.8.1",
+    "hardhat-deploy": "^0.11.44",
+    "hardhat-deploy-ethers": "^0.3.0-beta.13",
+    "solidity-bytes-utils": "^0.8.0"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "lzVersions": {
+    "default": [
+      "v2"
+    ]
+  }
+}