@layerzerolabs/lz-evm-oapp-v1 1.5.25

package/contracts/libraries/LzLib.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+pragma experimental ABIEncoderV2;
+
+library LzLib {
+    // LayerZero communication
+    struct CallParams {
+        address payable refundAddress;
+        address zroPaymentAddress;
+    }
+
+    //---------------------------------------------------------------------------
+    // Address type handling
+
+    struct AirdropParams {
+        uint airdropAmount;
+        bytes32 airdropAddress;
+    }
+
+    function buildAdapterParams(
+        LzLib.AirdropParams memory _airdropParams,
+        uint _uaGasLimit
+    ) internal pure returns (bytes memory adapterParams) {
+        if (_airdropParams.airdropAmount == 0 && _airdropParams.airdropAddress == bytes32(0x0)) {
+            adapterParams = buildDefaultAdapterParams(_uaGasLimit);
+        } else {
+            adapterParams = buildAirdropAdapterParams(_uaGasLimit, _airdropParams);
+        }
+    }
+
+    // Build Adapter Params
+    function buildDefaultAdapterParams(uint _uaGas) internal pure returns (bytes memory) {
+        // txType 1
+        // bytes  [2       32      ]
+        // fields [txType  extraGas]
+        return abi.encodePacked(uint16(1), _uaGas);
+    }
+
+    function buildAirdropAdapterParams(uint _uaGas, AirdropParams memory _params) internal pure returns (bytes memory) {
+        require(_params.airdropAmount > 0, "Airdrop amount must be greater than 0");
+        require(_params.airdropAddress != bytes32(0x0), "Airdrop address must be set");
+
+        // txType 2
+        // bytes  [2       32        32            bytes[]         ]
+        // fields [txType  extraGas  dstNativeAmt  dstNativeAddress]
+        return abi.encodePacked(uint16(2), _uaGas, _params.airdropAmount, _params.airdropAddress);
+    }
+
+    function getGasLimit(bytes memory _adapterParams) internal pure returns (uint gasLimit) {
+        require(_adapterParams.length == 34 || _adapterParams.length > 66, "Invalid adapterParams");
+        assembly {
+            gasLimit := mload(add(_adapterParams, 34))
+        }
+    }
+
+    // Decode Adapter Params
+    function decodeAdapterParams(
+        bytes memory _adapterParams
+    ) internal pure returns (uint16 txType, uint uaGas, uint airdropAmount, address payable airdropAddress) {
+        require(_adapterParams.length == 34 || _adapterParams.length > 66, "Invalid adapterParams");
+        assembly {
+            txType := mload(add(_adapterParams, 2))
+            uaGas := mload(add(_adapterParams, 34))
+        }
+        require(txType == 1 || txType == 2, "Unsupported txType");
+        require(uaGas > 0, "Gas too low");
+
+        if (txType == 2) {
+            assembly {
+                airdropAmount := mload(add(_adapterParams, 66))
+                airdropAddress := mload(add(_adapterParams, 86))
+            }
+        }
+    }
+
+    //---------------------------------------------------------------------------
+    // Address type handling
+    function bytes32ToAddress(bytes32 _bytes32Address) internal pure returns (address _address) {
+        return address(uint160(uint(_bytes32Address)));
+    }
+
+    function addressToBytes32(address _address) internal pure returns (bytes32 _bytes32Address) {
+        return bytes32(uint(uint160(_address)));
+    }
+}

package/contracts/lzApp/LzApp.sol

@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroReceiver.sol";
+import "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroUserApplicationConfig.sol";
+import "@layerzerolabs/lz-evm-v1-0.7/contracts/interfaces/ILayerZeroEndpoint.sol";
+import "../util/BytesLib.sol";
+
+/*
+ * a generic LzReceiver implementation
+ */
+abstract contract LzApp is Ownable, ILayerZeroReceiver, ILayerZeroUserApplicationConfig {
+    using BytesLib for bytes;
+
+    ILayerZeroEndpoint public immutable lzEndpoint;
+    mapping(uint16 => bytes) public trustedRemoteLookup;
+    mapping(uint16 => mapping(uint16 => uint)) public minDstGasLookup;
+    address public precrime;
+
+    event SetPrecrime(address precrime);
+    event SetTrustedRemote(uint16 _remoteChainId, bytes _path);
+    event SetTrustedRemoteAddress(uint16 _remoteChainId, bytes _remoteAddress);
+    event SetMinDstGas(uint16 _dstChainId, uint16 _type, uint _minDstGas);
+
+    constructor(address _endpoint) {
+        lzEndpoint = ILayerZeroEndpoint(_endpoint);
+    }
+
+    function lzReceive(
+        uint16 _srcChainId,
+        bytes calldata _srcAddress,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) public virtual override {
+        // lzReceive must be called by the endpoint for security
+        require(_msgSender() == address(lzEndpoint), "LzApp: invalid endpoint caller");
+
+        bytes memory trustedRemote = trustedRemoteLookup[_srcChainId];
+        // if will still block the message pathway from (srcChainId, srcAddress). should not receive message from untrusted remote.
+        require(
+            _srcAddress.length == trustedRemote.length &&
+                trustedRemote.length > 0 &&
+                keccak256(_srcAddress) == keccak256(trustedRemote),
+            "LzApp: invalid source sending contract"
+        );
+
+        _blockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
+    }
+
+    // abstract function - the default behaviour of LayerZero is blocking. See: NonblockingLzApp if you dont need to enforce ordered messaging
+    function _blockingLzReceive(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 _nonce,
+        bytes memory _payload
+    ) internal virtual;
+
+    function _lzSend(
+        uint16 _dstChainId,
+        bytes memory _payload,
+        address payable _refundAddress,
+        address _zroPaymentAddress,
+        bytes memory _adapterParams,
+        uint _nativeFee
+    ) internal virtual {
+        bytes memory trustedRemote = trustedRemoteLookup[_dstChainId];
+        require(trustedRemote.length != 0, "LzApp: destination chain is not a trusted source");
+        lzEndpoint.send{value: _nativeFee}(
+            _dstChainId,
+            trustedRemote,
+            _payload,
+            _refundAddress,
+            _zroPaymentAddress,
+            _adapterParams
+        );
+    }
+
+    function _checkGasLimit(
+        uint16 _dstChainId,
+        uint16 _type,
+        bytes memory _adapterParams,
+        uint _extraGas
+    ) internal view virtual {
+        uint providedGasLimit = _getGasLimit(_adapterParams);
+        uint minGasLimit = minDstGasLookup[_dstChainId][_type] + _extraGas;
+        require(minGasLimit > 0, "LzApp: minGasLimit not set");
+        require(providedGasLimit >= minGasLimit, "LzApp: gas limit is too low");
+    }
+
+    function _getGasLimit(bytes memory _adapterParams) internal pure virtual returns (uint gasLimit) {
+        require(_adapterParams.length >= 34, "LzApp: invalid adapterParams");
+        assembly {
+            gasLimit := mload(add(_adapterParams, 34))
+        }
+    }
+
+    //---------------------------UserApplication config----------------------------------------
+    function getConfig(
+        uint16 _version,
+        uint16 _chainId,
+        address,
+        uint _configType
+    ) external view returns (bytes memory) {
+        return lzEndpoint.getConfig(_version, _chainId, address(this), _configType);
+    }
+
+    // generic config for LayerZero user Application
+    function setConfig(
+        uint16 _version,
+        uint16 _chainId,
+        uint _configType,
+        bytes calldata _config
+    ) external override onlyOwner {
+        lzEndpoint.setConfig(_version, _chainId, _configType, _config);
+    }
+
+    function setSendVersion(uint16 _version) external override onlyOwner {
+        lzEndpoint.setSendVersion(_version);
+    }
+
+    function setReceiveVersion(uint16 _version) external override onlyOwner {
+        lzEndpoint.setReceiveVersion(_version);
+    }
+
+    function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external override onlyOwner {
+        lzEndpoint.forceResumeReceive(_srcChainId, _srcAddress);
+    }
+
+    // _path = abi.encodePacked(remoteAddress, localAddress)
+    // this function set the trusted path for the cross-chain communication
+    function setTrustedRemote(uint16 _srcChainId, bytes calldata _path) external onlyOwner {
+        trustedRemoteLookup[_srcChainId] = _path;
+        emit SetTrustedRemote(_srcChainId, _path);
+    }
+
+    function setTrustedRemoteAddress(uint16 _remoteChainId, bytes calldata _remoteAddress) external onlyOwner {
+        trustedRemoteLookup[_remoteChainId] = abi.encodePacked(_remoteAddress, address(this));
+        emit SetTrustedRemoteAddress(_remoteChainId, _remoteAddress);
+    }
+
+    function getTrustedRemoteAddress(uint16 _remoteChainId) external view returns (bytes memory) {
+        bytes memory path = trustedRemoteLookup[_remoteChainId];
+        require(path.length != 0, "LzApp: no trusted path record");
+        return path.slice(0, path.length - 20); // the last 20 bytes should be address(this)
+    }
+
+    function setPrecrime(address _precrime) external onlyOwner {
+        precrime = _precrime;
+        emit SetPrecrime(_precrime);
+    }
+
+    function setMinDstGas(uint16 _dstChainId, uint16 _packetType, uint _minGas) external onlyOwner {
+        require(_minGas > 0, "LzApp: invalid minGas");
+        minDstGasLookup[_dstChainId][_packetType] = _minGas;
+        emit SetMinDstGas(_dstChainId, _packetType, _minGas);
+    }
+
+    //--------------------------- VIEW FUNCTION ----------------------------------------
+    function isTrustedRemote(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool) {
+        bytes memory trustedSource = trustedRemoteLookup[_srcChainId];
+        return keccak256(trustedSource) == keccak256(_srcAddress);
+    }
+}

package/contracts/lzApp/NonblockingLzApp.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "./LzApp.sol";
+import "../util/ExcessivelySafeCall.sol";
+
+/*
+ * the default LayerZero messaging behaviour is blocking, i.e. any failed message will block the channel
+ * this abstract class try-catch all fail messages and store locally for future retry. hence, non-blocking
+ * NOTE: if the srcAddress is not configured properly, it will still block the message pathway from (srcChainId, srcAddress)
+ */
+abstract contract NonblockingLzApp is LzApp {
+    using ExcessivelySafeCall for address;
+
+    constructor(address _endpoint) LzApp(_endpoint) {}
+
+    mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) public failedMessages;
+
+    event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
+    event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
+
+    // overriding the virtual function in LzReceiver
+    function _blockingLzReceive(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 _nonce,
+        bytes memory _payload
+    ) internal virtual override {
+        (bool success, bytes memory reason) = address(this).excessivelySafeCall(
+            gasleft(),
+            150,
+            abi.encodeWithSelector(this.nonblockingLzReceive.selector, _srcChainId, _srcAddress, _nonce, _payload)
+        );
+        // try-catch all errors/exceptions
+        if (!success) {
+            _storeFailedMessage(_srcChainId, _srcAddress, _nonce, _payload, reason);
+        }
+    }
+
+    function _storeFailedMessage(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 _nonce,
+        bytes memory _payload,
+        bytes memory _reason
+    ) internal virtual {
+        failedMessages[_srcChainId][_srcAddress][_nonce] = keccak256(_payload);
+        emit MessageFailed(_srcChainId, _srcAddress, _nonce, _payload, _reason);
+    }
+
+    function nonblockingLzReceive(
+        uint16 _srcChainId,
+        bytes calldata _srcAddress,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) public virtual {
+        // only internal transaction
+        require(_msgSender() == address(this), "NonblockingLzApp: caller must be LzApp");
+        _nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
+    }
+
+    //@notice override this function
+    function _nonblockingLzReceive(
+        uint16 _srcChainId,
+        bytes memory _srcAddress,
+        uint64 _nonce,
+        bytes memory _payload
+    ) internal virtual;
+
+    function retryMessage(
+        uint16 _srcChainId,
+        bytes calldata _srcAddress,
+        uint64 _nonce,
+        bytes calldata _payload
+    ) public payable virtual {
+        // assert there is message to retry
+        bytes32 payloadHash = failedMessages[_srcChainId][_srcAddress][_nonce];
+        require(payloadHash != bytes32(0), "NonblockingLzApp: no stored message");
+        require(keccak256(_payload) == payloadHash, "NonblockingLzApp: invalid payload");
+        // clear the stored message
+        failedMessages[_srcChainId][_srcAddress][_nonce] = bytes32(0);
+        // execute the message. revert if it fails again
+        _nonblockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
+        emit RetryMessageSuccess(_srcChainId, _srcAddress, _nonce, payloadHash);
+    }
+}