@layerzerolabs/lz-evm-protocol-v2 2.0.2

package/contracts/interfaces/ILayerZeroEndpointV2.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IMessageLibManager } from "./IMessageLibManager.sol";
+import { IMessagingComposer } from "./IMessagingComposer.sol";
+import { IMessagingChannel } from "./IMessagingChannel.sol";
+import { IMessagingContext } from "./IMessagingContext.sol";
+
+struct MessagingParams {
+    uint32 dstEid;
+    bytes32 receiver;
+    bytes message;
+    bytes options;
+    bool payInLzToken;
+}
+
+struct MessagingReceipt {
+    bytes32 guid;
+    uint64 nonce;
+    MessagingFee fee;
+}
+
+struct MessagingFee {
+    uint256 nativeFee;
+    uint256 lzTokenFee;
+}
+
+struct Origin {
+    uint32 srcEid;
+    bytes32 sender;
+    uint64 nonce;
+}
+
+enum ExecutionState {
+    NotExecutable,
+    Executable,
+    Executed
+}
+
+interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
+    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);
+
+    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);
+
+    event PacketDelivered(Origin origin, address receiver);
+
+    event LzReceiveAlert(
+        address indexed receiver,
+        address indexed executor,
+        Origin origin,
+        bytes32 guid,
+        uint256 gas,
+        uint256 value,
+        bytes message,
+        bytes extraData,
+        bytes reason
+    );
+
+    event LzTokenSet(address token);
+
+    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);
+
+    function send(
+        MessagingParams calldata _params,
+        address _refundAddress
+    ) external payable returns (MessagingReceipt memory);
+
+    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;
+
+    function verifiable(
+        Origin calldata _origin,
+        address _receiver,
+        address _receiveLib,
+        bytes32 _payloadHash
+    ) external view returns (bool);
+
+    function executable(Origin calldata _origin, address _receiver) external view returns (ExecutionState);
+
+    function lzReceive(
+        Origin calldata _origin,
+        address _receiver,
+        bytes32 _guid,
+        bytes calldata _message,
+        bytes calldata _extraData
+    ) external payable;
+
+    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
+    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;
+
+    function setLzToken(address _lzToken) external;
+
+    function lzToken() external view returns (address);
+
+    function nativeToken() external view returns (address);
+
+    function setDelegate(address _delegate) external;
+}

package/contracts/interfaces/ILayerZeroReceiver.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { Origin } from "./ILayerZeroEndpointV2.sol";
+
+interface ILayerZeroReceiver {
+    function allowInitializePath(Origin calldata _origin) external view returns (bool);
+
+    // todo: move to OAppReceiver? it is just convention for executor. we may can change it in a new Receiver version
+    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);
+
+    function lzReceive(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) external payable;
+}

package/contracts/interfaces/IMessageLib.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import { SetConfigParam } from "./IMessageLibManager.sol";
+
+enum MessageLibType {
+    Send,
+    Receive,
+    SendAndReceive
+}
+
+interface IMessageLib is IERC165 {
+    function setConfig(address _oapp, SetConfigParam[] calldata _config) external;
+
+    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view returns (bytes memory config);
+
+    function isSupportedEid(uint32 _eid) external view returns (bool);
+
+    // message libs of same major version are compatible
+    function version() external view returns (uint64 major, uint8 minor, uint8 endpointVersion);
+
+    function messageLibType() external view returns (MessageLibType);
+}

package/contracts/interfaces/IMessageLibManager.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+struct SetConfigParam {
+    uint32 eid;
+    uint32 configType;
+    bytes config;
+}
+
+interface IMessageLibManager {
+    struct Timeout {
+        address lib;
+        uint256 expiry;
+    }
+
+    event LibraryRegistered(address newLib);
+    event DefaultSendLibrarySet(uint32 eid, address newLib);
+    event DefaultReceiveLibrarySet(uint32 eid, address oldLib, address newLib);
+    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
+    event SendLibrarySet(address sender, uint32 eid, address newLib);
+    event ReceiveLibrarySet(address receiver, uint32 eid, address oldLib, address newLib);
+    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);
+
+    function registerLibrary(address _lib) external;
+
+    function isRegisteredLibrary(address _lib) external view returns (bool);
+
+    function getRegisteredLibraries() external view returns (address[] memory);
+
+    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;
+
+    function defaultSendLibrary(uint32 _eid) external view returns (address);
+
+    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _timeout) external;
+
+    function defaultReceiveLibrary(uint32 _eid) external view returns (address);
+
+    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;
+
+    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);
+
+    function isSupportedEid(uint32 _eid) external view returns (bool);
+
+    /// ------------------- OApp interfaces -------------------
+    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;
+
+    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);
+
+    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);
+
+    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;
+
+    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);
+
+    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _gracePeriod) external;
+
+    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);
+
+    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;
+
+    function getConfig(
+        address _oapp,
+        address _lib,
+        uint32 _eid,
+        uint32 _configType
+    ) external view returns (bytes memory config);
+}

package/contracts/interfaces/IMessagingChannel.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IMessagingChannel {
+    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
+    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
+    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
+
+    function eid() external view returns (uint32);
+
+    // this is an emergency function if a message cannot be verified for some reasons
+    // required to provide _nextNonce to avoid race condition
+    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;
+
+    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;
+
+    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;
+
+    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);
+
+    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
+
+    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);
+
+    function inboundPayloadHash(
+        address _receiver,
+        uint32 _srcEid,
+        bytes32 _sender,
+        uint64 _nonce
+    ) external view returns (bytes32);
+}

package/contracts/interfaces/IMessagingComposer.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IMessagingComposer {
+    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
+    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
+    event LzComposeAlert(
+        address indexed from,
+        address indexed to,
+        address indexed executor,
+        bytes32 guid,
+        uint16 index,
+        uint256 gas,
+        uint256 value,
+        bytes message,
+        bytes extraData,
+        bytes reason
+    );
+
+    function composeQueue(
+        address _from,
+        address _to,
+        bytes32 _guid,
+        uint16 _index
+    ) external view returns (bytes32 messageHash);
+
+    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;
+
+    function lzCompose(
+        address _from,
+        address _to,
+        bytes32 _guid,
+        uint16 _index,
+        bytes calldata _message,
+        bytes calldata _extraData
+    ) external payable;
+}

package/contracts/interfaces/IMessagingContext.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+interface IMessagingContext {
+    function isSendingMessage() external view returns (bool);
+
+    function getSendContext() external view returns (uint32 dstEid, address sender);
+}

package/contracts/interfaces/ISendLib.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { MessagingFee } from "./ILayerZeroEndpointV2.sol";
+import { IMessageLib } from "./IMessageLib.sol";
+
+struct Packet {
+    uint64 nonce;
+    uint32 srcEid;
+    address sender;
+    uint32 dstEid;
+    bytes32 receiver;
+    bytes32 guid;
+    bytes message;
+}
+
+interface ISendLib is IMessageLib {
+    function send(
+        Packet calldata _packet,
+        bytes calldata _options,
+        bool _payInLzToken
+    ) external returns (MessagingFee memory, bytes memory encodedPacket);
+
+    function quote(
+        Packet calldata _packet,
+        bytes calldata _options,
+        bool _payInLzToken
+    ) external view returns (MessagingFee memory);
+
+    function setTreasury(address _treasury) external;
+
+    function withdrawFee(address _to, uint256 _amount) external;
+
+    function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external;
+}

package/contracts/libs/AddressCast.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { Errors } from "./Errors.sol";
+
+library AddressCast {
+    function toBytes32(bytes calldata _addressBytes) internal pure returns (bytes32 result) {
+        if (_addressBytes.length > 32) revert Errors.InvalidAddress();
+        result = bytes32(_addressBytes);
+        unchecked {
+            uint256 offset = 32 - _addressBytes.length;
+            result = result >> (offset * 8);
+        }
+    }
+
+    function toBytes32(address _address) internal pure returns (bytes32 result) {
+        result = bytes32(uint256(uint160(_address)));
+    }
+
+    function toBytes(bytes32 _addressBytes32, uint256 _size) internal pure returns (bytes memory result) {
+        if (_size == 0 || _size > 32) revert Errors.InvalidSizeForAddress();
+        result = new bytes(_size);
+        unchecked {
+            uint256 offset = 256 - _size * 8;
+            assembly {
+                mstore(add(result, 32), shl(offset, _addressBytes32))
+            }
+        }
+    }
+
+    function toAddress(bytes32 _addressBytes32) internal pure returns (address result) {
+        result = address(uint160(uint256(_addressBytes32)));
+    }
+
+    function toAddress(bytes calldata _addressBytes) internal pure returns (address result) {
+        if (_addressBytes.length != 20) revert Errors.InvalidAddress();
+        result = address(bytes20(_addressBytes));
+    }
+}

package/contracts/libs/CalldataBytesLib.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+library CalldataBytesLib {
+    function toU8(bytes calldata _bytes, uint256 _start) internal pure returns (uint8) {
+        return uint8(_bytes[_start]);
+    }
+
+    function toU16(bytes calldata _bytes, uint256 _start) internal pure returns (uint16) {
+        unchecked {
+            uint256 end = _start + 2;
+            return uint16(bytes2(_bytes[_start:end]));
+        }
+    }
+
+    function toU32(bytes calldata _bytes, uint256 _start) internal pure returns (uint32) {
+        unchecked {
+            uint256 end = _start + 4;
+            return uint32(bytes4(_bytes[_start:end]));
+        }
+    }
+
+    function toU64(bytes calldata _bytes, uint256 _start) internal pure returns (uint64) {
+        unchecked {
+            uint256 end = _start + 8;
+            return uint64(bytes8(_bytes[_start:end]));
+        }
+    }
+
+    function toU128(bytes calldata _bytes, uint256 _start) internal pure returns (uint128) {
+        unchecked {
+            uint256 end = _start + 16;
+            return uint128(bytes16(_bytes[_start:end]));
+        }
+    }
+
+    function toU256(bytes calldata _bytes, uint256 _start) internal pure returns (uint256) {
+        unchecked {
+            uint256 end = _start + 32;
+            return uint256(bytes32(_bytes[_start:end]));
+        }
+    }
+
+    function toAddr(bytes calldata _bytes, uint256 _start) internal pure returns (address) {
+        unchecked {
+            uint256 end = _start + 20;
+            return address(bytes20(_bytes[_start:end]));
+        }
+    }
+
+    function toB32(bytes calldata _bytes, uint256 _start) internal pure returns (bytes32) {
+        unchecked {
+            uint256 end = _start + 32;
+            return bytes32(_bytes[_start:end]);
+        }
+    }
+}

package/contracts/libs/Errors.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+library Errors {
+    error LzTokenUnavailable();
+    error OnlyAltToken();
+    error InvalidReceiveLibrary();
+    error InvalidNonce(uint64 nonce);
+    error InvalidArgument();
+    error InvalidExpiry();
+    error InvalidAmount(uint256 required, uint256 supplied);
+    error OnlyRegisteredOrDefaultLib();
+    error OnlyRegisteredLib();
+    error OnlyNonDefaultLib();
+    error Unauthorized();
+    error DefaultSendLibUnavailable();
+    error DefaultReceiveLibUnavailable();
+    error PathNotInitializable();
+    error PathNotVerifiable();
+    error OnlySendLib();
+    error OnlyReceiveLib();
+    error UnsupportedEid();
+    error UnsupportedInterface();
+    error AlreadyRegistered();
+    error SameValue();
+    error InvalidPayloadHash();
+    error PayloadHashNotFound(bytes32 expected, bytes32 actual);
+    error ComposeNotFound(bytes32 expected, bytes32 actual);
+    error ComposeExists();
+    error SendReentrancy();
+    error NotImplemented();
+    error InvalidAddress();
+    error InvalidSizeForAddress();
+    error InsufficientFee(
+        uint256 requiredNative,
+        uint256 suppliedNative,
+        uint256 requiredLzToken,
+        uint256 suppliedLzToken
+    );
+    error ZeroLzTokenFee();
+}

package/contracts/libs/GUID.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { AddressCast } from "./AddressCast.sol";
+
+library GUID {
+    using AddressCast for address;
+
+    function generate(
+        uint64 _nonce,
+        uint32 _srcEid,
+        address _sender,
+        uint32 _dstEid,
+        bytes32 _receiver
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_nonce, _srcEid, _sender.toBytes32(), _dstEid, _receiver));
+    }
+}

package/contracts/libs/Transfer.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity ^0.8.22;
+
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+library Transfer {
+    using SafeERC20 for IERC20;
+
+    address internal constant ADDRESS_ZERO = address(0);
+
+    error TransferNativeFailed(address _to, uint256 _value);
+    error ToAddressIsZero();
+
+    function native(address _to, uint256 _value) internal {
+        if (_to == ADDRESS_ZERO) revert ToAddressIsZero();
+        (bool success, ) = _to.call{ value: _value }("");
+        if (!success) revert TransferNativeFailed(_to, _value);
+    }
+
+    function token(address _token, address _to, uint256 _value) internal {
+        if (_to == ADDRESS_ZERO) revert ToAddressIsZero();
+        IERC20(_token).safeTransfer(_to, _value);
+    }
+
+    function nativeOrToken(address _token, address _to, uint256 _value) internal {
+        if (_token == ADDRESS_ZERO) {
+            native(_to, _value);
+        } else {
+            token(_token, _to, _value);
+        }
+    }
+}

package/contracts/messagelib/BlockedMessageLib.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LZBL-1.2
+
+pragma solidity 0.8.22;
+
+import { ERC165 } from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+import { IMessageLib, MessageLibType } from "../interfaces/IMessageLib.sol";
+import { Errors } from "../libs/Errors.sol";
+
+contract BlockedMessageLib is ERC165 {
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return interfaceId == type(IMessageLib).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    function version() external pure returns (uint64 major, uint8 minor, uint8 endpointVersion) {
+        return (type(uint64).max, type(uint8).max, 2);
+    }
+
+    function messageLibType() external pure returns (MessageLibType) {
+        return MessageLibType.SendAndReceive;
+    }
+
+    function isSupportedEid(uint32) external pure returns (bool) {
+        return true;
+    }
+
+    fallback() external {
+        revert Errors.NotImplemented();
+    }
+}