ETH Price: $2,648.17 (+5.55%)

Transaction Decoder

Block:
22440960 at May-08-2025 07:44:59 PM +UTC
Transaction Fee:
0.001620017447105952 ETH $4.29
Gas Used:
254,547 Gas / 6.364315616 Gwei

Emitted Events:

114 NativeOFT.Transfer( from=0x0000000000000000000000000000000000000000, to=[Receiver] SwappableBridge, value=2729302036249378 )
115 NativeOFT.Deposit( _dst=[Receiver] SwappableBridge, _amount=2729302036249378 )
116 NativeOFT.Transfer( from=[Receiver] SwappableBridge, to=NativeOFT, value=2729302036249378 )
117 OptimizedTransparentUpgradeableProxy.0xdf21c415b78ed2552cc9971249e32a053abce6087a0ae0fbf3f78db5174a3493( 0xdf21c415b78ed2552cc9971249e32a053abce6087a0ae0fbf3f78db5174a3493, 00000000000000000000000000000000000000000000000000019badcb4636e8 )
118 UltraLightNodeV2.RelayerParams( adapterParams=0x00010000000000000000000000000000000000000000000000000000000000030D40, outboundProofType=2 )
119 OptimizedTransparentUpgradeableProxy.0x4e41ee13e03cd5e0446487b524fdc48af6acf26c074dacdbdfb6b574b42c8146( 0x4e41ee13e03cd5e0446487b524fdc48af6acf26c074dacdbdfb6b574b42c8146, 00000000000000000000000000000000000000000000000000000000000000a1, 0000000000000000000000000000000000000000000000000000000000000002, 000000000000000000000000000000000000000000000000000000000000000f, 0000000000000000000000004f7a67464b5976d7547c860109e4432d50afb38e, 00000000000000000000000000000000000000000000000000000000036d909c )
120 UltraLightNodeV2.Packet( payload=0x000000000000010E00654F7A67464B5976D7547C860109E4432D50AFB38E00A14F7A67464B5976D7547C860109E4432D50AFB38E000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000009B249265AFB22000000000000000000000000000000000000000000000000000000000000001445F1141E1C9BE68ED5F6BA9C3F25E80443A2605B000000000000000000000000 )

Account State Difference:

  Address   Before After State Difference Code
0x45F1141E...443a2605b
0.005736914159359286 Eth
Nonce: 22
0.000934948899757296 Eth
Nonce: 23
0.00480196525960199
(Titan Builder)
14.253437805329837872 Eth14.253692352330092419 Eth0.000254547000254547
0x4D73AdB7...401A178E2
(Layer Zero: Ultra Light Node v2)
4.227741797796804401 Eth4.228194443573051061 Eth0.00045264577624666
0x4f7A6746...d50AfB38e 76.475248829408319179 Eth76.477978131444568557 Eth0.002729302036249378
0x5B905fE0...FAbf76068
(LayerZero: Nonce)
0x66A71Dce...C225Cd675
(LayerZero: Ethereum Endpoint)

Execution Trace

ETH 0.003317741545370036 SwappableBridge.bridge( amountIn=2729302036249378, dstChainId=161, to=0x45F1141E1C9BE68ED5f6Ba9c3F25E80443a2605b, refundAddress=0x45F1141E1C9BE68ED5f6Ba9c3F25E80443a2605b, zroPaymentAddress=0x0000000000000000000000000000000000000000, adapterParams=0x )
  • ETH 0.002729302036249378 NativeOFT.CALL( )
  • ETH 0.000588439509120658 NativeOFT.sendFrom( _from=0x0A9f824C05A74F577A536A8A0c673183a872Dff4, _dstChainId=161, _toAddress=0x45F1141E1C9BE68ED5F6BA9C3F25E80443A2605B, _amount=2729302036249378, _refundAddress=0x45F1141E1C9BE68ED5f6Ba9c3F25E80443a2605b, _zroPaymentAddress=0x0000000000000000000000000000000000000000, _adapterParams=0x )
    • ETH 0.000588439509120658 Endpoint.send( _dstChainId=161, _destination=0x4F7A67464B5976D7547C860109E4432D50AFB38E4F7A67464B5976D7547C860109E4432D50AFB38E, _payload=0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000009B249265AFB22000000000000000000000000000000000000000000000000000000000000001445F1141E1C9BE68ED5F6BA9C3F25E80443A2605B000000000000000000000000, _refundAddress=0x45F1141E1C9BE68ED5f6Ba9c3F25E80443a2605b, _zroPaymentAddress=0x0000000000000000000000000000000000000000, _adapterParams=0x )
      • ETH 0.000588439509120658 UltraLightNodeV2.send( _ua=0x4f7A67464B5976d7547c860109e4432d50AfB38e, 270, _dstChainId=161, _path=0x4F7A67464B5976D7547C860109E4432D50AFB38E4F7A67464B5976D7547C860109E4432D50AFB38E, _payload=0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000009B249265AFB22000000000000000000000000000000000000000000000000000000000000001445F1141E1C9BE68ED5F6BA9C3F25E80443A2605B000000000000000000000000, _refundAddress=0x45F1141E1C9BE68ED5f6Ba9c3F25E80443a2605b, _zroPaymentAddress=0x0000000000000000000000000000000000000000, _adapterParams=0x )
        • NonceContract.increment( _chainId=161, _ua=0x4f7A67464B5976d7547c860109e4432d50AfB38e, _path=0x4F7A67464B5976D7547C860109E4432D50AFB38E4F7A67464B5976D7547C860109E4432D50AFB38E ) => ( 270 )
          • Endpoint.getSendLibraryAddress( _userApplication=0x4f7A67464B5976d7547c860109e4432d50AfB38e ) => ( sendLibraryAddress=0x4D73AdB72bC3DD368966edD0f0b2148401A178E2 )
          • OptimizedTransparentUpgradeableProxy.5886ea65( )
            • 0xb830a5afcbebb936c30c607a18bbba9f5b0a592f.5886ea65( )
              • OptimizedTransparentUpgradeableProxy.88a4124c( )
              • OptimizedTransparentUpgradeableProxy.c5e193cd( )
                • 0x3eea8d627ab6983fffc7027ee623fd7699343fc1.c5e193cd( )
                  • OptimizedTransparentUpgradeableProxy.7bc3c9ab( )
                  • TreasuryV2.getFees( payInZro=False, relayerFee=452645718734568, oracleFee=57512092 ) => ( 0 )
                  • ETH 0.000135793732873998 0x45f1141e1c9be68ed5f6ba9c3f25e80443a2605b.CALL( )
                    File 1 of 9: SwappableBridge
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
                    import "@layerzerolabs/solidity-examples/contracts/token/oft/IOFTCore.sol";
                    import "./INativeOFT.sol";
                    contract SwappableBridge {
                        IOFTCore public immutable oft;
                        INativeOFT public immutable nativeOft;
                        IUniswapV2Router02 public immutable uniswapRouter;
                        constructor(address _oft, address _nativeOft, address _uniswapRouter) {
                            require(_oft != address(0), "SwappableBridge: invalid OFT address");
                            require(_nativeOft != address(0), "SwappableBridge: invalid Native OFT address");
                            require(_uniswapRouter != address(0), "SwappableBridge: invalid Uniswap Router address");
                            oft = IOFTCore(_oft);
                            nativeOft = INativeOFT(_nativeOft);
                            uniswapRouter = IUniswapV2Router02(_uniswapRouter);
                        }
                        function swapAndBridge(uint amountIn, uint amountOutMin, uint16 dstChainId, address to, address payable refundAddress, address zroPaymentAddress, bytes calldata adapterParams) external payable {
                            require(to != address(0), "SwappableBridge: invalid to address");
                            require(msg.value >= amountIn, "SwappableBridge: not enough value sent");
                            address[] memory path = new address[](2);
                            path[0] = uniswapRouter.WETH();
                            path[1] = address(oft);
                            uint[] memory amounts = uniswapRouter.swapExactETHForTokens{value: amountIn}(amountOutMin, path, address(this), block.timestamp);
                            oft.sendFrom{value: msg.value - amountIn}(address(this), dstChainId, abi.encodePacked(to), amounts[1], refundAddress, zroPaymentAddress, adapterParams);
                        }
                        function bridge(uint amountIn, uint16 dstChainId, address to, address payable refundAddress, address zroPaymentAddress, bytes calldata adapterParams) external payable {
                            require(to != address(0), "SwappableBridge: invalid to address");
                            require(msg.value >= amountIn, "SwappableBridge: not enough value sent");
                            nativeOft.deposit{value: amountIn}();
                            nativeOft.sendFrom{value: msg.value - amountIn}(address(this), dstChainId, abi.encodePacked(to), amountIn, refundAddress, zroPaymentAddress, adapterParams);
                        }
                    }// SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Interface of the ERC165 standard, as defined in the
                     * https://eips.ethereum.org/EIPS/eip-165[EIP].
                     *
                     * Implementers can declare support of contract interfaces, which can then be
                     * queried by others ({ERC165Checker}).
                     *
                     * For an implementation, see {ERC165}.
                     */
                    interface IERC165 {
                        /**
                         * @dev Returns true if this contract implements the interface defined by
                         * `interfaceId`. See the corresponding
                         * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
                         * to learn more about how these ids are created.
                         *
                         * This function call must use less than 30 000 gas.
                         */
                        function supportsInterface(bytes4 interfaceId) external view returns (bool);
                    }
                    pragma solidity >=0.6.2;
                    interface IUniswapV2Router01 {
                        function factory() external pure returns (address);
                        function WETH() external pure returns (address);
                        function addLiquidity(
                            address tokenA,
                            address tokenB,
                            uint amountADesired,
                            uint amountBDesired,
                            uint amountAMin,
                            uint amountBMin,
                            address to,
                            uint deadline
                        ) external returns (uint amountA, uint amountB, uint liquidity);
                        function addLiquidityETH(
                            address token,
                            uint amountTokenDesired,
                            uint amountTokenMin,
                            uint amountETHMin,
                            address to,
                            uint deadline
                        ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
                        function removeLiquidity(
                            address tokenA,
                            address tokenB,
                            uint liquidity,
                            uint amountAMin,
                            uint amountBMin,
                            address to,
                            uint deadline
                        ) external returns (uint amountA, uint amountB);
                        function removeLiquidityETH(
                            address token,
                            uint liquidity,
                            uint amountTokenMin,
                            uint amountETHMin,
                            address to,
                            uint deadline
                        ) external returns (uint amountToken, uint amountETH);
                        function removeLiquidityWithPermit(
                            address tokenA,
                            address tokenB,
                            uint liquidity,
                            uint amountAMin,
                            uint amountBMin,
                            address to,
                            uint deadline,
                            bool approveMax, uint8 v, bytes32 r, bytes32 s
                        ) external returns (uint amountA, uint amountB);
                        function removeLiquidityETHWithPermit(
                            address token,
                            uint liquidity,
                            uint amountTokenMin,
                            uint amountETHMin,
                            address to,
                            uint deadline,
                            bool approveMax, uint8 v, bytes32 r, bytes32 s
                        ) external returns (uint amountToken, uint amountETH);
                        function swapExactTokensForTokens(
                            uint amountIn,
                            uint amountOutMin,
                            address[] calldata path,
                            address to,
                            uint deadline
                        ) external returns (uint[] memory amounts);
                        function swapTokensForExactTokens(
                            uint amountOut,
                            uint amountInMax,
                            address[] calldata path,
                            address to,
                            uint deadline
                        ) external returns (uint[] memory amounts);
                        function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
                            external
                            payable
                            returns (uint[] memory amounts);
                        function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
                            external
                            returns (uint[] memory amounts);
                        function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
                            external
                            returns (uint[] memory amounts);
                        function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
                            external
                            payable
                            returns (uint[] memory amounts);
                        function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
                        function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
                        function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
                        function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
                        function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
                    }
                    pragma solidity >=0.6.2;
                    import './IUniswapV2Router01.sol';
                    interface IUniswapV2Router02 is IUniswapV2Router01 {
                        function removeLiquidityETHSupportingFeeOnTransferTokens(
                            address token,
                            uint liquidity,
                            uint amountTokenMin,
                            uint amountETHMin,
                            address to,
                            uint deadline
                        ) external returns (uint amountETH);
                        function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
                            address token,
                            uint liquidity,
                            uint amountTokenMin,
                            uint amountETHMin,
                            address to,
                            uint deadline,
                            bool approveMax, uint8 v, bytes32 r, bytes32 s
                        ) external returns (uint amountETH);
                        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
                            uint amountIn,
                            uint amountOutMin,
                            address[] calldata path,
                            address to,
                            uint deadline
                        ) external;
                        function swapExactETHForTokensSupportingFeeOnTransferTokens(
                            uint amountOutMin,
                            address[] calldata path,
                            address to,
                            uint deadline
                        ) external payable;
                        function swapExactTokensForETHSupportingFeeOnTransferTokens(
                            uint amountIn,
                            uint amountOutMin,
                            address[] calldata path,
                            address to,
                            uint deadline
                        ) external;
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
                    /**
                     * @dev Interface of the IOFT core standard
                     */
                    interface IOFTCore is IERC165 {
                        /**
                         * @dev estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`)
                         * _dstChainId - L0 defined chain id to send tokens too
                         * _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain
                         * _amount - amount of the tokens to transfer
                         * _useZro - indicates to use zro to pay L0 fees
                         * _adapterParam - flexible bytes array to indicate messaging adapter services in L0
                         */
                        function estimateSendFee(uint16 _dstChainId, bytes calldata _toAddress, uint _amount, bool _useZro, bytes calldata _adapterParams) external view returns (uint nativeFee, uint zroFee);
                        /**
                         * @dev send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from`
                         * `_from` the owner of token
                         * `_dstChainId` the destination chain identifier
                         * `_toAddress` can be any size depending on the `dstChainId`.
                         * `_amount` the quantity of tokens in wei
                         * `_refundAddress` the address LayerZero refunds if too much message fee is sent
                         * `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token)
                         * `_adapterParams` is a flexible bytes array to indicate messaging adapter services
                         */
                        function sendFrom(address _from, uint16 _dstChainId, bytes calldata _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        /**
                         * @dev returns the circulating amount of tokens on current chain
                         */
                        function circulatingSupply() external view returns (uint);
                        /**
                         * @dev returns the address of the ERC20 token
                         */
                        function token() external view returns (address);
                        /**
                         * @dev Emitted when `_amount` tokens are moved from the `_sender` to (`_dstChainId`, `_toAddress`)
                         * `_nonce` is the outbound nonce
                         */
                        event SendToChain(uint16 indexed _dstChainId, address indexed _from, bytes _toAddress, uint _amount);
                        /**
                         * @dev Emitted when `_amount` tokens are received from `_srcChainId` into the `_toAddress` on the local chain.
                         * `_nonce` is the inbound nonce.
                         */
                        event ReceiveFromChain(uint16 indexed _srcChainId, address indexed _to, uint _amount);
                        event SetUseCustomAdapterParams(bool _useCustomAdapterParams);
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "@layerzerolabs/solidity-examples/contracts/token/oft/IOFTCore.sol";
                    interface INativeOFT is IOFTCore {
                        function deposit() external payable;
                    }

                    File 2 of 9: NativeOFT
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
                    import "../OFT.sol";
                    contract NativeOFT is OFT, ReentrancyGuard {
                        event Deposit(address indexed _dst, uint _amount);
                        event Withdrawal(address indexed _src, uint _amount);
                        constructor(string memory _name, string memory _symbol, address _lzEndpoint) OFT(_name, _symbol, _lzEndpoint) {}
                        function sendFrom(address _from, uint16 _dstChainId, bytes calldata _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) public payable virtual override(OFTCore, IOFTCore) {
                            _send(_from, _dstChainId, _toAddress, _amount, _refundAddress, _zroPaymentAddress, _adapterParams);
                        }
                        function _send(address _from, uint16 _dstChainId, bytes memory _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes memory _adapterParams) internal virtual override(OFTCore) {
                            uint messageFee = _debitFromNative(_from, _dstChainId, _toAddress, _amount);
                            bytes memory lzPayload = abi.encode(PT_SEND, _toAddress, _amount);
                            if (useCustomAdapterParams) {
                                _checkGasLimit(_dstChainId, PT_SEND, _adapterParams, NO_EXTRA_GAS);
                            } else {
                                require(_adapterParams.length == 0, "NativeOFT: _adapterParams must be empty.");
                            }
                            _lzSend(_dstChainId, lzPayload, _refundAddress, _zroPaymentAddress, _adapterParams, messageFee);
                        }
                        function deposit() public payable {
                            _mint(msg.sender, msg.value);
                            emit Deposit(msg.sender, msg.value);
                        }
                        function withdraw(uint _amount) public nonReentrant {
                            require(balanceOf(msg.sender) >= _amount, "NativeOFT: Insufficient balance.");
                            _burn(msg.sender, _amount);
                            (bool success, ) = msg.sender.call{value: _amount}("");
                            require(success, "NativeOFT: failed to unwrap");
                            emit Withdrawal(msg.sender, _amount);
                        }
                        function _debitFromNative(address _from, uint16, bytes memory, uint _amount) internal returns (uint messageFee) {
                            messageFee = msg.sender == _from ? _debitMsgSender(_amount) : _debitMsgFrom(_from, _amount);
                        }
                        function _debitMsgSender(uint _amount) internal returns (uint messageFee) {
                            uint msgSenderBalance = balanceOf(msg.sender);
                            if (msgSenderBalance < _amount) {
                                require(msgSenderBalance + msg.value >= _amount, "NativeOFT: Insufficient msg.value");
                                // user can cover difference with additional msg.value ie. wrapping
                                uint mintAmount = _amount - msgSenderBalance;
                                _mint(address(msg.sender), mintAmount);
                                // update the messageFee to take out mintAmount
                                messageFee = msg.value - mintAmount;
                            } else {
                                messageFee = msg.value;
                            }
                            _transfer(msg.sender, address(this), _amount);
                            return messageFee;
                        }
                        function _debitMsgFrom(address _from, uint _amount) internal returns (uint messageFee) {
                            uint msgFromBalance = balanceOf(_from);
                            if (msgFromBalance < _amount) {
                                require(msgFromBalance + msg.value >= _amount, "NativeOFT: Insufficient msg.value");
                                // user can cover difference with additional msg.value ie. wrapping
                                uint mintAmount = _amount - msgFromBalance;
                                _mint(address(msg.sender), mintAmount);
                                // transfer the differential amount to the contract
                                _transfer(msg.sender, address(this), mintAmount);
                                // overwrite the _amount to take the rest of the balance from the _from address
                                _amount = msgFromBalance;
                                // update the messageFee to take out mintAmount
                                messageFee = msg.value - mintAmount;
                            } else {
                                messageFee = msg.value;
                            }
                            _spendAllowance(_from, msg.sender, _amount);
                            _transfer(_from, address(this), _amount);
                            return messageFee;
                        }
                        function _creditTo(uint16, address _toAddress, uint _amount) internal override(OFT) returns(uint) {
                            _burn(address(this), _amount);
                            (bool success, ) = _toAddress.call{value: _amount}("");
                            require(success, "NativeOFT: failed to _creditTo");
                            return _amount;
                        }
                        receive() external payable {
                            deposit();
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Provides information about the current execution context, including the
                     * sender of the transaction and its data. While these are generally available
                     * via msg.sender and msg.data, they should not be accessed in such a direct
                     * manner, since when dealing with meta-transactions the account sending and
                     * paying for execution may not be the actual sender (as far as an application
                     * is concerned).
                     *
                     * This contract is only required for intermediate, library-like contracts.
                     */
                    abstract contract Context {
                        function _msgSender() internal view virtual returns (address) {
                            return msg.sender;
                        }
                        function _msgData() internal view virtual returns (bytes calldata) {
                            return msg.data;
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
                    pragma solidity ^0.8.0;
                    import "../utils/Context.sol";
                    /**
                     * @dev Contract module which provides a basic access control mechanism, where
                     * there is an account (an owner) that can be granted exclusive access to
                     * specific functions.
                     *
                     * By default, the owner account will be the one that deploys the contract. This
                     * can later be changed with {transferOwnership}.
                     *
                     * This module is used through inheritance. It will make available the modifier
                     * `onlyOwner`, which can be applied to your functions to restrict their use to
                     * the owner.
                     */
                    abstract contract Ownable is Context {
                        address private _owner;
                        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
                        /**
                         * @dev Initializes the contract setting the deployer as the initial owner.
                         */
                        constructor() {
                            _transferOwnership(_msgSender());
                        }
                        /**
                         * @dev Throws if called by any account other than the owner.
                         */
                        modifier onlyOwner() {
                            _checkOwner();
                            _;
                        }
                        /**
                         * @dev Returns the address of the current owner.
                         */
                        function owner() public view virtual returns (address) {
                            return _owner;
                        }
                        /**
                         * @dev Throws if the sender is not the owner.
                         */
                        function _checkOwner() internal view virtual {
                            require(owner() == _msgSender(), "Ownable: caller is not the owner");
                        }
                        /**
                         * @dev Leaves the contract without owner. It will not be possible to call
                         * `onlyOwner` functions anymore. Can only be called by the current owner.
                         *
                         * NOTE: Renouncing ownership will leave the contract without an owner,
                         * thereby removing any functionality that is only available to the owner.
                         */
                        function renounceOwnership() public virtual onlyOwner {
                            _transferOwnership(address(0));
                        }
                        /**
                         * @dev Transfers ownership of the contract to a new account (`newOwner`).
                         * Can only be called by the current owner.
                         */
                        function transferOwnership(address newOwner) public virtual onlyOwner {
                            require(newOwner != address(0), "Ownable: new owner is the zero address");
                            _transferOwnership(newOwner);
                        }
                        /**
                         * @dev Transfers ownership of the contract to a new account (`newOwner`).
                         * Internal function without access restriction.
                         */
                        function _transferOwnership(address newOwner) internal virtual {
                            address oldOwner = _owner;
                            _owner = newOwner;
                            emit OwnershipTransferred(oldOwner, newOwner);
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    interface ILayerZeroReceiver {
                        // @notice LayerZero endpoint will invoke this function to deliver the message on the destination
                        // @param _srcChainId - the source endpoint identifier
                        // @param _srcAddress - the source sending contract address from the source chain
                        // @param _nonce - the ordered message nonce
                        // @param _payload - the signed payload is the UA bytes has encoded to be sent
                        function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    interface ILayerZeroUserApplicationConfig {
                        // @notice set the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        // @param _config - configuration in the bytes. can encode arbitrary content.
                        function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;
                        // @notice set the send() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setSendVersion(uint16 _version) external;
                        // @notice set the lzReceive() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setReceiveVersion(uint16 _version) external;
                        // @notice Only when the UA needs to resume the message flow in blocking mode and clear the stored payload
                        // @param _srcChainId - the chainId of the source chain
                        // @param _srcAddress - the contract address of the source contract at the source chain
                        function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    import "./ILayerZeroUserApplicationConfig.sol";
                    interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
                        // @notice send a LayerZero message to the specified address at a LayerZero endpoint.
                        // @param _dstChainId - the destination chain identifier
                        // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
                        // @param _payload - a custom bytes payload to send to the destination contract
                        // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
                        // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
                        // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
                        function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        // @notice used by the messaging library to publish verified payload
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source contract (as bytes) at the source chain
                        // @param _dstAddress - the address on destination chain
                        // @param _nonce - the unbound message ordering nonce
                        // @param _gasLimit - the gas limit for external contract execution
                        // @param _payload - verified payload to send to the destination contract
                        function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;
                        // @notice get the inboundNonce of a lzApp from a source chain which could be EVM or non-EVM chain
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);
                        // @notice get the outboundNonce from this source chain which, consequently, is always an EVM
                        // @param _srcAddress - the source chain contract address
                        function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);
                        // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery
                        // @param _dstChainId - the destination chain identifier
                        // @param _userApplication - the user app address on this EVM chain
                        // @param _payload - the custom message to send over LayerZero
                        // @param _payInZRO - if false, user app pays the protocol fee in native token
                        // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain
                        function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);
                        // @notice get this Endpoint's immutable source identifier
                        function getChainId() external view returns (uint16);
                        // @notice the interface to retry failed message on this Endpoint destination
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        // @param _payload - the payload to be retried
                        function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;
                        // @notice query if any STORED payload (message blocking) at the endpoint.
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);
                        // @notice query if the _libraryAddress is valid for sending msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getSendLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the _libraryAddress is valid for receiving msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getReceiveLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the non-reentrancy guard for send() is on
                        // @return true if the guard is on. false otherwise
                        function isSendingPayload() external view returns (bool);
                        // @notice query if the non-reentrancy guard for receive() is on
                        // @return true if the guard is on. false otherwise
                        function isReceivingPayload() external view returns (bool);
                        // @notice get the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _userApplication - the contract address of the user application
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
                        // @notice get the send() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getSendVersion(address _userApplication) external view returns (uint16);
                        // @notice get the lzReceive() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getReceiveVersion(address _userApplication) external view returns (uint16);
                    }
                    // SPDX-License-Identifier: Unlicense
                    /*
                     * @title Solidity Bytes Arrays Utils
                     * @author Gonçalo Sá <[email protected]>
                     *
                     * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
                     *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
                     */
                    pragma solidity >=0.8.0 <0.9.0;
                    library BytesLib {
                        function concat(
                            bytes memory _preBytes,
                            bytes memory _postBytes
                        )
                        internal
                        pure
                        returns (bytes memory)
                        {
                            bytes memory tempBytes;
                            assembly {
                            // Get a location of some free memory and store it in tempBytes as
                            // Solidity does for memory variables.
                                tempBytes := mload(0x40)
                            // Store the length of the first bytes array at the beginning of
                            // the memory for tempBytes.
                                let length := mload(_preBytes)
                                mstore(tempBytes, length)
                            // Maintain a memory counter for the current write location in the
                            // temp bytes array by adding the 32 bytes for the array length to
                            // the starting location.
                                let mc := add(tempBytes, 0x20)
                            // Stop copying when the memory counter reaches the length of the
                            // first bytes array.
                                let end := add(mc, length)
                                for {
                                // Initialize a copy counter to the start of the _preBytes data,
                                // 32 bytes into its memory.
                                    let cc := add(_preBytes, 0x20)
                                } lt(mc, end) {
                                // Increase both counters by 32 bytes each iteration.
                                    mc := add(mc, 0x20)
                                    cc := add(cc, 0x20)
                                } {
                                // Write the _preBytes data into the tempBytes memory 32 bytes
                                // at a time.
                                    mstore(mc, mload(cc))
                                }
                            // Add the length of _postBytes to the current length of tempBytes
                            // and store it as the new length in the first 32 bytes of the
                            // tempBytes memory.
                                length := mload(_postBytes)
                                mstore(tempBytes, add(length, mload(tempBytes)))
                            // Move the memory counter back from a multiple of 0x20 to the
                            // actual end of the _preBytes data.
                                mc := end
                            // Stop copying when the memory counter reaches the new combined
                            // length of the arrays.
                                end := add(mc, length)
                                for {
                                    let cc := add(_postBytes, 0x20)
                                } lt(mc, end) {
                                    mc := add(mc, 0x20)
                                    cc := add(cc, 0x20)
                                } {
                                    mstore(mc, mload(cc))
                                }
                            // Update the free-memory pointer by padding our last write location
                            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
                            // next 32 byte block, then round down to the nearest multiple of
                            // 32. If the sum of the length of the two arrays is zero then add
                            // one before rounding down to leave a blank 32 bytes (the length block with 0).
                                mstore(0x40, and(
                                add(add(end, iszero(add(length, mload(_preBytes)))), 31),
                                not(31) // Round down to the nearest 32 bytes.
                                ))
                            }
                            return tempBytes;
                        }
                        function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
                            assembly {
                            // Read the first 32 bytes of _preBytes storage, which is the length
                            // of the array. (We don't need to use the offset into the slot
                            // because arrays use the entire slot.)
                                let fslot := sload(_preBytes.slot)
                            // Arrays of 31 bytes or less have an even value in their slot,
                            // while longer arrays have an odd value. The actual length is
                            // the slot divided by two for odd values, and the lowest order
                            // byte divided by two for even values.
                            // If the slot is even, bitwise and the slot with 255 and divide by
                            // two to get the length. If the slot is odd, bitwise and the slot
                            // with -1 and divide by two.
                                let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
                                let mlength := mload(_postBytes)
                                let newlength := add(slength, mlength)
                            // slength can contain both the length and contents of the array
                            // if length < 32 bytes so let's prepare for that
                            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                                switch add(lt(slength, 32), lt(newlength, 32))
                                case 2 {
                                // Since the new array still fits in the slot, we just need to
                                // update the contents of the slot.
                                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                                    sstore(
                                    _preBytes.slot,
                                    // all the modifications to the slot are inside this
                                    // next block
                                    add(
                                    // we can just add to the slot contents because the
                                    // bytes we want to change are the LSBs
                                    fslot,
                                    add(
                                    mul(
                                    div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                    ),
                                    // and now shift left the number of bytes to
                                    // leave space for the length in the slot
                                    exp(0x100, sub(32, newlength))
                                    ),
                                    // increase length by the double of the memory
                                    // bytes length
                                    mul(mlength, 2)
                                    )
                                    )
                                    )
                                }
                                case 1 {
                                // The stored value fits in the slot, but the combined value
                                // will exceed it.
                                // get the keccak hash to get the contents of the array
                                    mstore(0x0, _preBytes.slot)
                                    let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                                // save new length
                                    sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                                // The contents of the _postBytes array start 32 bytes into
                                // the structure. Our first read should obtain the `submod`
                                // bytes that can fit into the unused space in the last word
                                // of the stored array. To get this, we read 32 bytes starting
                                // from `submod`, so the data we read overlaps with the array
                                // contents by `submod` bytes. Masking the lowest-order
                                // `submod` bytes allows us to add that value directly to the
                                // stored value.
                                    let submod := sub(32, slength)
                                    let mc := add(_postBytes, submod)
                                    let end := add(_postBytes, mlength)
                                    let mask := sub(exp(0x100, submod), 1)
                                    sstore(
                                    sc,
                                    add(
                                    and(
                                    fslot,
                                    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                                    ),
                                    and(mload(mc), mask)
                                    )
                                    )
                                    for {
                                        mc := add(mc, 0x20)
                                        sc := add(sc, 1)
                                    } lt(mc, end) {
                                        sc := add(sc, 1)
                                        mc := add(mc, 0x20)
                                    } {
                                        sstore(sc, mload(mc))
                                    }
                                    mask := exp(0x100, sub(mc, end))
                                    sstore(sc, mul(div(mload(mc), mask), mask))
                                }
                                default {
                                // get the keccak hash to get the contents of the array
                                    mstore(0x0, _preBytes.slot)
                                // Start copying to the last used word of the stored array.
                                    let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                                // save new length
                                    sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                                // Copy over the first `submod` bytes of the new data as in
                                // case 1 above.
                                    let slengthmod := mod(slength, 32)
                                    let mlengthmod := mod(mlength, 32)
                                    let submod := sub(32, slengthmod)
                                    let mc := add(_postBytes, submod)
                                    let end := add(_postBytes, mlength)
                                    let mask := sub(exp(0x100, submod), 1)
                                    sstore(sc, add(sload(sc), and(mload(mc), mask)))
                                    for {
                                        sc := add(sc, 1)
                                        mc := add(mc, 0x20)
                                    } lt(mc, end) {
                                        sc := add(sc, 1)
                                        mc := add(mc, 0x20)
                                    } {
                                        sstore(sc, mload(mc))
                                    }
                                    mask := exp(0x100, sub(mc, end))
                                    sstore(sc, mul(div(mload(mc), mask), mask))
                                }
                            }
                        }
                        function slice(
                            bytes memory _bytes,
                            uint256 _start,
                            uint256 _length
                        )
                        internal
                        pure
                        returns (bytes memory)
                        {
                            require(_length + 31 >= _length, "slice_overflow");
                            require(_bytes.length >= _start + _length, "slice_outOfBounds");
                            bytes memory tempBytes;
                            assembly {
                                switch iszero(_length)
                                case 0 {
                                // Get a location of some free memory and store it in tempBytes as
                                // Solidity does for memory variables.
                                    tempBytes := mload(0x40)
                                // The first word of the slice result is potentially a partial
                                // word read from the original array. To read it, we calculate
                                // the length of that partial word and start copying that many
                                // bytes into the array. The first word we copy will start with
                                // data we don't care about, but the last `lengthmod` bytes will
                                // land at the beginning of the contents of the new array. When
                                // we're done copying, we overwrite the full first word with
                                // the actual length of the slice.
                                    let lengthmod := and(_length, 31)
                                // The multiplication in the next line is necessary
                                // because when slicing multiples of 32 bytes (lengthmod == 0)
                                // the following copy loop was copying the origin's length
                                // and then ending prematurely not copying everything it should.
                                    let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                                    let end := add(mc, _length)
                                    for {
                                    // The multiplication in the next line has the same exact purpose
                                    // as the one above.
                                        let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                                    } lt(mc, end) {
                                        mc := add(mc, 0x20)
                                        cc := add(cc, 0x20)
                                    } {
                                        mstore(mc, mload(cc))
                                    }
                                    mstore(tempBytes, _length)
                                //update free-memory pointer
                                //allocating the array padded to 32 bytes like the compiler does now
                                    mstore(0x40, and(add(mc, 31), not(31)))
                                }
                                //if we want a zero-length slice let's just return a zero-length array
                                default {
                                    tempBytes := mload(0x40)
                                //zero out the 32 bytes slice we are about to return
                                //we need to do it because Solidity does not garbage collect
                                    mstore(tempBytes, 0)
                                    mstore(0x40, add(tempBytes, 0x20))
                                }
                            }
                            return tempBytes;
                        }
                        function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
                            require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
                            address tempAddress;
                            assembly {
                                tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
                            }
                            return tempAddress;
                        }
                        function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
                            require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
                            uint8 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x1), _start))
                            }
                            return tempUint;
                        }
                        function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
                            require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
                            uint16 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x2), _start))
                            }
                            return tempUint;
                        }
                        function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
                            require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
                            uint32 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x4), _start))
                            }
                            return tempUint;
                        }
                        function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
                            require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
                            uint64 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x8), _start))
                            }
                            return tempUint;
                        }
                        function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
                            require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
                            uint96 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0xc), _start))
                            }
                            return tempUint;
                        }
                        function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
                            require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
                            uint128 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x10), _start))
                            }
                            return tempUint;
                        }
                        function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
                            require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
                            uint256 tempUint;
                            assembly {
                                tempUint := mload(add(add(_bytes, 0x20), _start))
                            }
                            return tempUint;
                        }
                        function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
                            require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
                            bytes32 tempBytes32;
                            assembly {
                                tempBytes32 := mload(add(add(_bytes, 0x20), _start))
                            }
                            return tempBytes32;
                        }
                        function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
                            bool success = true;
                            assembly {
                                let length := mload(_preBytes)
                            // if lengths don't match the arrays are not equal
                                switch eq(length, mload(_postBytes))
                                case 1 {
                                // cb is a circuit breaker in the for loop since there's
                                //  no said feature for inline assembly loops
                                // cb = 1 - don't breaker
                                // cb = 0 - break
                                    let cb := 1
                                    let mc := add(_preBytes, 0x20)
                                    let end := add(mc, length)
                                    for {
                                        let cc := add(_postBytes, 0x20)
                                    // the next line is the loop condition:
                                    // while(uint256(mc < end) + cb == 2)
                                    } eq(add(lt(mc, end), cb), 2) {
                                        mc := add(mc, 0x20)
                                        cc := add(cc, 0x20)
                                    } {
                                    // if any of these checks fails then arrays are not equal
                                        if iszero(eq(mload(mc), mload(cc))) {
                                        // unsuccess:
                                            success := 0
                                            cb := 0
                                        }
                                    }
                                }
                                default {
                                // unsuccess:
                                    success := 0
                                }
                            }
                            return success;
                        }
                        function equalStorage(
                            bytes storage _preBytes,
                            bytes memory _postBytes
                        )
                        internal
                        view
                        returns (bool)
                        {
                            bool success = true;
                            assembly {
                            // we know _preBytes_offset is 0
                                let fslot := sload(_preBytes.slot)
                            // Decode the length of the stored array like in concatStorage().
                                let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
                                let mlength := mload(_postBytes)
                            // if lengths don't match the arrays are not equal
                                switch eq(slength, mlength)
                                case 1 {
                                // slength can contain both the length and contents of the array
                                // if length < 32 bytes so let's prepare for that
                                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                                    if iszero(iszero(slength)) {
                                        switch lt(slength, 32)
                                        case 1 {
                                        // blank the last byte which is the length
                                            fslot := mul(div(fslot, 0x100), 0x100)
                                            if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                                            // unsuccess:
                                                success := 0
                                            }
                                        }
                                        default {
                                        // cb is a circuit breaker in the for loop since there's
                                        //  no said feature for inline assembly loops
                                        // cb = 1 - don't breaker
                                        // cb = 0 - break
                                            let cb := 1
                                        // get the keccak hash to get the contents of the array
                                            mstore(0x0, _preBytes.slot)
                                            let sc := keccak256(0x0, 0x20)
                                            let mc := add(_postBytes, 0x20)
                                            let end := add(mc, mlength)
                                        // the next line is the loop condition:
                                        // while(uint256(mc < end) + cb == 2)
                                            for {} eq(add(lt(mc, end), cb), 2) {
                                                sc := add(sc, 1)
                                                mc := add(mc, 0x20)
                                            } {
                                                if iszero(eq(sload(sc), mload(mc))) {
                                                // unsuccess:
                                                    success := 0
                                                    cb := 0
                                                }
                                            }
                                        }
                                    }
                                }
                                default {
                                // unsuccess:
                                    success := 0
                                }
                            }
                            return success;
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "@openzeppelin/contracts/access/Ownable.sol";
                    import "../interfaces/ILayerZeroReceiver.sol";
                    import "../interfaces/ILayerZeroUserApplicationConfig.sol";
                    import "../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);
                        }
                    }
                    // SPDX-License-Identifier: MIT OR Apache-2.0
                    pragma solidity >=0.7.6;
                    library ExcessivelySafeCall {
                        uint256 constant LOW_28_MASK =
                        0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                        /// @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 excessivelySafeCall(
                            address _target,
                            uint256 _gas,
                            uint16 _maxCopy,
                            bytes memory _calldata
                        ) internal returns (bool, bytes memory) {
                            // 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
                                0, // ether value
                                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);
                        }
                        /// @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 excessivelySafeStaticCall(
                            address _target,
                            uint256 _gas,
                            uint16 _maxCopy,
                            bytes memory _calldata
                        ) internal view returns (bool, bytes memory) {
                            // 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);
                        }
                        /**
                         * @notice Swaps function selectors in encoded contract calls
                         * @dev Allows reuse of encoded calldata for functions with identical
                         * argument types but different names. It simply swaps out the first 4 bytes
                         * for the new selector. This function modifies memory in place, and should
                         * only be used with caution.
                         * @param _newSelector The new 4-byte selector
                         * @param _buf The encoded contract args
                         */
                        function swapSelector(bytes4 _newSelector, bytes memory _buf)
                        internal
                        pure
                        {
                            require(_buf.length >= 4);
                            uint256 _mask = LOW_28_MASK;
                            assembly {
                            // load the first word of
                                let _word := mload(add(_buf, 0x20))
                            // mask out the top 4 bytes
                            // /x
                                _word := and(_word, _mask)
                                _word := or(_newSelector, _word)
                                mstore(add(_buf, 0x20), _word)
                            }
                        }
                    }
                    // 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);
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
                    /**
                     * @dev Interface of the IOFT core standard
                     */
                    interface IOFTCore is IERC165 {
                        /**
                         * @dev estimate send token `_tokenId` to (`_dstChainId`, `_toAddress`)
                         * _dstChainId - L0 defined chain id to send tokens too
                         * _toAddress - dynamic bytes array which contains the address to whom you are sending tokens to on the dstChain
                         * _amount - amount of the tokens to transfer
                         * _useZro - indicates to use zro to pay L0 fees
                         * _adapterParam - flexible bytes array to indicate messaging adapter services in L0
                         */
                        function estimateSendFee(uint16 _dstChainId, bytes calldata _toAddress, uint _amount, bool _useZro, bytes calldata _adapterParams) external view returns (uint nativeFee, uint zroFee);
                        /**
                         * @dev send `_amount` amount of token to (`_dstChainId`, `_toAddress`) from `_from`
                         * `_from` the owner of token
                         * `_dstChainId` the destination chain identifier
                         * `_toAddress` can be any size depending on the `dstChainId`.
                         * `_amount` the quantity of tokens in wei
                         * `_refundAddress` the address LayerZero refunds if too much message fee is sent
                         * `_zroPaymentAddress` set to address(0x0) if not paying in ZRO (LayerZero Token)
                         * `_adapterParams` is a flexible bytes array to indicate messaging adapter services
                         */
                        function sendFrom(address _from, uint16 _dstChainId, bytes calldata _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        /**
                         * @dev returns the circulating amount of tokens on current chain
                         */
                        function circulatingSupply() external view returns (uint);
                        /**
                         * @dev returns the address of the ERC20 token
                         */
                        function token() external view returns (address);
                        /**
                         * @dev Emitted when `_amount` tokens are moved from the `_sender` to (`_dstChainId`, `_toAddress`)
                         * `_nonce` is the outbound nonce
                         */
                        event SendToChain(uint16 indexed _dstChainId, address indexed _from, bytes _toAddress, uint _amount);
                        /**
                         * @dev Emitted when `_amount` tokens are received from `_srcChainId` into the `_toAddress` on the local chain.
                         * `_nonce` is the inbound nonce.
                         */
                        event ReceiveFromChain(uint16 indexed _srcChainId, address indexed _to, uint _amount);
                        event SetUseCustomAdapterParams(bool _useCustomAdapterParams);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
                    pragma solidity ^0.8.0;
                    import "./IERC165.sol";
                    /**
                     * @dev Implementation of the {IERC165} interface.
                     *
                     * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
                     * for the additional interface id that will be supported. For example:
                     *
                     * ```solidity
                     * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                     *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
                     * }
                     * ```
                     *
                     * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
                     */
                    abstract contract ERC165 is IERC165 {
                        /**
                         * @dev See {IERC165-supportsInterface}.
                         */
                        function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                            return interfaceId == type(IERC165).interfaceId;
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Interface of the ERC20 standard as defined in the EIP.
                     */
                    interface IERC20 {
                        /**
                         * @dev Emitted when `value` tokens are moved from one account (`from`) to
                         * another (`to`).
                         *
                         * Note that `value` may be zero.
                         */
                        event Transfer(address indexed from, address indexed to, uint256 value);
                        /**
                         * @dev Emitted when the allowance of a `spender` for an `owner` is set by
                         * a call to {approve}. `value` is the new allowance.
                         */
                        event Approval(address indexed owner, address indexed spender, uint256 value);
                        /**
                         * @dev Returns the amount of tokens in existence.
                         */
                        function totalSupply() external view returns (uint256);
                        /**
                         * @dev Returns the amount of tokens owned by `account`.
                         */
                        function balanceOf(address account) external view returns (uint256);
                        /**
                         * @dev Moves `amount` tokens from the caller's account to `to`.
                         *
                         * Returns a boolean value indicating whether the operation succeeded.
                         *
                         * Emits a {Transfer} event.
                         */
                        function transfer(address to, uint256 amount) external returns (bool);
                        /**
                         * @dev Returns the remaining number of tokens that `spender` will be
                         * allowed to spend on behalf of `owner` through {transferFrom}. This is
                         * zero by default.
                         *
                         * This value changes when {approve} or {transferFrom} are called.
                         */
                        function allowance(address owner, address spender) external view returns (uint256);
                        /**
                         * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
                         *
                         * Returns a boolean value indicating whether the operation succeeded.
                         *
                         * IMPORTANT: Beware that changing an allowance with this method brings the risk
                         * that someone may use both the old and the new allowance by unfortunate
                         * transaction ordering. One possible solution to mitigate this race
                         * condition is to first reduce the spender's allowance to 0 and set the
                         * desired value afterwards:
                         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                         *
                         * Emits an {Approval} event.
                         */
                        function approve(address spender, uint256 amount) external returns (bool);
                        /**
                         * @dev Moves `amount` tokens from `from` to `to` using the
                         * allowance mechanism. `amount` is then deducted from the caller's
                         * allowance.
                         *
                         * Returns a boolean value indicating whether the operation succeeded.
                         *
                         * Emits a {Transfer} event.
                         */
                        function transferFrom(
                            address from,
                            address to,
                            uint256 amount
                        ) external returns (bool);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
                    pragma solidity ^0.8.0;
                    import "../IERC20.sol";
                    /**
                     * @dev Interface for the optional metadata functions from the ERC20 standard.
                     *
                     * _Available since v4.1._
                     */
                    interface IERC20Metadata is IERC20 {
                        /**
                         * @dev Returns the name of the token.
                         */
                        function name() external view returns (string memory);
                        /**
                         * @dev Returns the symbol of the token.
                         */
                        function symbol() external view returns (string memory);
                        /**
                         * @dev Returns the decimals places of the token.
                         */
                        function decimals() external view returns (uint8);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
                    pragma solidity ^0.8.0;
                    import "./IERC20.sol";
                    import "./extensions/IERC20Metadata.sol";
                    import "../../utils/Context.sol";
                    /**
                     * @dev Implementation of the {IERC20} interface.
                     *
                     * This implementation is agnostic to the way tokens are created. This means
                     * that a supply mechanism has to be added in a derived contract using {_mint}.
                     * For a generic mechanism see {ERC20PresetMinterPauser}.
                     *
                     * TIP: For a detailed writeup see our guide
                     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
                     * to implement supply mechanisms].
                     *
                     * We have followed general OpenZeppelin Contracts guidelines: functions revert
                     * instead returning `false` on failure. This behavior is nonetheless
                     * conventional and does not conflict with the expectations of ERC20
                     * applications.
                     *
                     * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
                     * This allows applications to reconstruct the allowance for all accounts just
                     * by listening to said events. Other implementations of the EIP may not emit
                     * these events, as it isn't required by the specification.
                     *
                     * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
                     * functions have been added to mitigate the well-known issues around setting
                     * allowances. See {IERC20-approve}.
                     */
                    contract ERC20 is Context, IERC20, IERC20Metadata {
                        mapping(address => uint256) private _balances;
                        mapping(address => mapping(address => uint256)) private _allowances;
                        uint256 private _totalSupply;
                        string private _name;
                        string private _symbol;
                        /**
                         * @dev Sets the values for {name} and {symbol}.
                         *
                         * The default value of {decimals} is 18. To select a different value for
                         * {decimals} you should overload it.
                         *
                         * All two of these values are immutable: they can only be set once during
                         * construction.
                         */
                        constructor(string memory name_, string memory symbol_) {
                            _name = name_;
                            _symbol = symbol_;
                        }
                        /**
                         * @dev Returns the name of the token.
                         */
                        function name() public view virtual override returns (string memory) {
                            return _name;
                        }
                        /**
                         * @dev Returns the symbol of the token, usually a shorter version of the
                         * name.
                         */
                        function symbol() public view virtual override returns (string memory) {
                            return _symbol;
                        }
                        /**
                         * @dev Returns the number of decimals used to get its user representation.
                         * For example, if `decimals` equals `2`, a balance of `505` tokens should
                         * be displayed to a user as `5.05` (`505 / 10 ** 2`).
                         *
                         * Tokens usually opt for a value of 18, imitating the relationship between
                         * Ether and Wei. This is the value {ERC20} uses, unless this function is
                         * overridden;
                         *
                         * NOTE: This information is only used for _display_ purposes: it in
                         * no way affects any of the arithmetic of the contract, including
                         * {IERC20-balanceOf} and {IERC20-transfer}.
                         */
                        function decimals() public view virtual override returns (uint8) {
                            return 18;
                        }
                        /**
                         * @dev See {IERC20-totalSupply}.
                         */
                        function totalSupply() public view virtual override returns (uint256) {
                            return _totalSupply;
                        }
                        /**
                         * @dev See {IERC20-balanceOf}.
                         */
                        function balanceOf(address account) public view virtual override returns (uint256) {
                            return _balances[account];
                        }
                        /**
                         * @dev See {IERC20-transfer}.
                         *
                         * Requirements:
                         *
                         * - `to` cannot be the zero address.
                         * - the caller must have a balance of at least `amount`.
                         */
                        function transfer(address to, uint256 amount) public virtual override returns (bool) {
                            address owner = _msgSender();
                            _transfer(owner, to, amount);
                            return true;
                        }
                        /**
                         * @dev See {IERC20-allowance}.
                         */
                        function allowance(address owner, address spender) public view virtual override returns (uint256) {
                            return _allowances[owner][spender];
                        }
                        /**
                         * @dev See {IERC20-approve}.
                         *
                         * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
                         * `transferFrom`. This is semantically equivalent to an infinite approval.
                         *
                         * Requirements:
                         *
                         * - `spender` cannot be the zero address.
                         */
                        function approve(address spender, uint256 amount) public virtual override returns (bool) {
                            address owner = _msgSender();
                            _approve(owner, spender, amount);
                            return true;
                        }
                        /**
                         * @dev See {IERC20-transferFrom}.
                         *
                         * Emits an {Approval} event indicating the updated allowance. This is not
                         * required by the EIP. See the note at the beginning of {ERC20}.
                         *
                         * NOTE: Does not update the allowance if the current allowance
                         * is the maximum `uint256`.
                         *
                         * Requirements:
                         *
                         * - `from` and `to` cannot be the zero address.
                         * - `from` must have a balance of at least `amount`.
                         * - the caller must have allowance for ``from``'s tokens of at least
                         * `amount`.
                         */
                        function transferFrom(
                            address from,
                            address to,
                            uint256 amount
                        ) public virtual override returns (bool) {
                            address spender = _msgSender();
                            _spendAllowance(from, spender, amount);
                            _transfer(from, to, amount);
                            return true;
                        }
                        /**
                         * @dev Atomically increases the allowance granted to `spender` by the caller.
                         *
                         * This is an alternative to {approve} that can be used as a mitigation for
                         * problems described in {IERC20-approve}.
                         *
                         * Emits an {Approval} event indicating the updated allowance.
                         *
                         * Requirements:
                         *
                         * - `spender` cannot be the zero address.
                         */
                        function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
                            address owner = _msgSender();
                            _approve(owner, spender, allowance(owner, spender) + addedValue);
                            return true;
                        }
                        /**
                         * @dev Atomically decreases the allowance granted to `spender` by the caller.
                         *
                         * This is an alternative to {approve} that can be used as a mitigation for
                         * problems described in {IERC20-approve}.
                         *
                         * Emits an {Approval} event indicating the updated allowance.
                         *
                         * Requirements:
                         *
                         * - `spender` cannot be the zero address.
                         * - `spender` must have allowance for the caller of at least
                         * `subtractedValue`.
                         */
                        function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
                            address owner = _msgSender();
                            uint256 currentAllowance = allowance(owner, spender);
                            require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
                            unchecked {
                                _approve(owner, spender, currentAllowance - subtractedValue);
                            }
                            return true;
                        }
                        /**
                         * @dev Moves `amount` of tokens from `from` to `to`.
                         *
                         * This internal function is equivalent to {transfer}, and can be used to
                         * e.g. implement automatic token fees, slashing mechanisms, etc.
                         *
                         * Emits a {Transfer} event.
                         *
                         * Requirements:
                         *
                         * - `from` cannot be the zero address.
                         * - `to` cannot be the zero address.
                         * - `from` must have a balance of at least `amount`.
                         */
                        function _transfer(
                            address from,
                            address to,
                            uint256 amount
                        ) internal virtual {
                            require(from != address(0), "ERC20: transfer from the zero address");
                            require(to != address(0), "ERC20: transfer to the zero address");
                            _beforeTokenTransfer(from, to, amount);
                            uint256 fromBalance = _balances[from];
                            require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
                            unchecked {
                                _balances[from] = fromBalance - amount;
                                // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
                                // decrementing then incrementing.
                                _balances[to] += amount;
                            }
                            emit Transfer(from, to, amount);
                            _afterTokenTransfer(from, to, amount);
                        }
                        /** @dev Creates `amount` tokens and assigns them to `account`, increasing
                         * the total supply.
                         *
                         * Emits a {Transfer} event with `from` set to the zero address.
                         *
                         * Requirements:
                         *
                         * - `account` cannot be the zero address.
                         */
                        function _mint(address account, uint256 amount) internal virtual {
                            require(account != address(0), "ERC20: mint to the zero address");
                            _beforeTokenTransfer(address(0), account, amount);
                            _totalSupply += amount;
                            unchecked {
                                // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
                                _balances[account] += amount;
                            }
                            emit Transfer(address(0), account, amount);
                            _afterTokenTransfer(address(0), account, amount);
                        }
                        /**
                         * @dev Destroys `amount` tokens from `account`, reducing the
                         * total supply.
                         *
                         * Emits a {Transfer} event with `to` set to the zero address.
                         *
                         * Requirements:
                         *
                         * - `account` cannot be the zero address.
                         * - `account` must have at least `amount` tokens.
                         */
                        function _burn(address account, uint256 amount) internal virtual {
                            require(account != address(0), "ERC20: burn from the zero address");
                            _beforeTokenTransfer(account, address(0), amount);
                            uint256 accountBalance = _balances[account];
                            require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
                            unchecked {
                                _balances[account] = accountBalance - amount;
                                // Overflow not possible: amount <= accountBalance <= totalSupply.
                                _totalSupply -= amount;
                            }
                            emit Transfer(account, address(0), amount);
                            _afterTokenTransfer(account, address(0), amount);
                        }
                        /**
                         * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
                         *
                         * This internal function is equivalent to `approve`, and can be used to
                         * e.g. set automatic allowances for certain subsystems, etc.
                         *
                         * Emits an {Approval} event.
                         *
                         * Requirements:
                         *
                         * - `owner` cannot be the zero address.
                         * - `spender` cannot be the zero address.
                         */
                        function _approve(
                            address owner,
                            address spender,
                            uint256 amount
                        ) internal virtual {
                            require(owner != address(0), "ERC20: approve from the zero address");
                            require(spender != address(0), "ERC20: approve to the zero address");
                            _allowances[owner][spender] = amount;
                            emit Approval(owner, spender, amount);
                        }
                        /**
                         * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
                         *
                         * Does not update the allowance amount in case of infinite allowance.
                         * Revert if not enough allowance is available.
                         *
                         * Might emit an {Approval} event.
                         */
                        function _spendAllowance(
                            address owner,
                            address spender,
                            uint256 amount
                        ) internal virtual {
                            uint256 currentAllowance = allowance(owner, spender);
                            if (currentAllowance != type(uint256).max) {
                                require(currentAllowance >= amount, "ERC20: insufficient allowance");
                                unchecked {
                                    _approve(owner, spender, currentAllowance - amount);
                                }
                            }
                        }
                        /**
                         * @dev Hook that is called before any transfer of tokens. This includes
                         * minting and burning.
                         *
                         * Calling conditions:
                         *
                         * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
                         * will be transferred to `to`.
                         * - when `from` is zero, `amount` tokens will be minted for `to`.
                         * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
                         * - `from` and `to` are never both zero.
                         *
                         * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
                         */
                        function _beforeTokenTransfer(
                            address from,
                            address to,
                            uint256 amount
                        ) internal virtual {}
                        /**
                         * @dev Hook that is called after any transfer of tokens. This includes
                         * minting and burning.
                         *
                         * Calling conditions:
                         *
                         * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
                         * has been transferred to `to`.
                         * - when `from` is zero, `amount` tokens have been minted for `to`.
                         * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
                         * - `from` and `to` are never both zero.
                         *
                         * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
                         */
                        function _afterTokenTransfer(
                            address from,
                            address to,
                            uint256 amount
                        ) internal virtual {}
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Interface of the ERC165 standard, as defined in the
                     * https://eips.ethereum.org/EIPS/eip-165[EIP].
                     *
                     * Implementers can declare support of contract interfaces, which can then be
                     * queried by others ({ERC165Checker}).
                     *
                     * For an implementation, see {ERC165}.
                     */
                    interface IERC165 {
                        /**
                         * @dev Returns true if this contract implements the interface defined by
                         * `interfaceId`. See the corresponding
                         * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
                         * to learn more about how these ids are created.
                         *
                         * This function call must use less than 30 000 gas.
                         */
                        function supportsInterface(bytes4 interfaceId) external view returns (bool);
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.5.0;
                    import "./IOFTCore.sol";
                    import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                    /**
                     * @dev Interface of the OFT standard
                     */
                    interface IOFT is IOFTCore, IERC20 {
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "../../lzApp/NonblockingLzApp.sol";
                    import "./IOFTCore.sol";
                    import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
                    abstract contract OFTCore is NonblockingLzApp, ERC165, IOFTCore {
                        using BytesLib for bytes;
                        uint public constant NO_EXTRA_GAS = 0;
                        // packet type
                        uint16 public constant PT_SEND = 0;
                        bool public useCustomAdapterParams;
                        constructor(address _lzEndpoint) NonblockingLzApp(_lzEndpoint) {}
                        function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
                            return interfaceId == type(IOFTCore).interfaceId || super.supportsInterface(interfaceId);
                        }
                        function estimateSendFee(uint16 _dstChainId, bytes calldata _toAddress, uint _amount, bool _useZro, bytes calldata _adapterParams) public view virtual override returns (uint nativeFee, uint zroFee) {
                            // mock the payload for sendFrom()
                            bytes memory payload = abi.encode(PT_SEND, _toAddress, _amount);
                            return lzEndpoint.estimateFees(_dstChainId, address(this), payload, _useZro, _adapterParams);
                        }
                        function sendFrom(address _from, uint16 _dstChainId, bytes calldata _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) public payable virtual override {
                            _send(_from, _dstChainId, _toAddress, _amount, _refundAddress, _zroPaymentAddress, _adapterParams);
                        }
                        function setUseCustomAdapterParams(bool _useCustomAdapterParams) public virtual onlyOwner {
                            useCustomAdapterParams = _useCustomAdapterParams;
                            emit SetUseCustomAdapterParams(_useCustomAdapterParams);
                        }
                        function _nonblockingLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) internal virtual override {
                            uint16 packetType;
                            assembly {
                                packetType := mload(add(_payload, 32))
                            }
                            if (packetType == PT_SEND) {
                                _sendAck(_srcChainId, _srcAddress, _nonce, _payload);
                            } else {
                                revert("OFTCore: unknown packet type");
                            }
                        }
                        function _send(address _from, uint16 _dstChainId, bytes memory _toAddress, uint _amount, address payable _refundAddress, address _zroPaymentAddress, bytes memory _adapterParams) internal virtual {
                            _checkAdapterParams(_dstChainId, PT_SEND, _adapterParams, NO_EXTRA_GAS);
                            uint amount = _debitFrom(_from, _dstChainId, _toAddress, _amount);
                            bytes memory lzPayload = abi.encode(PT_SEND, _toAddress, amount);
                            _lzSend(_dstChainId, lzPayload, _refundAddress, _zroPaymentAddress, _adapterParams, msg.value);
                            emit SendToChain(_dstChainId, _from, _toAddress, amount);
                        }
                        function _sendAck(uint16 _srcChainId, bytes memory, uint64, bytes memory _payload) internal virtual {
                            (, bytes memory toAddressBytes, uint amount) = abi.decode(_payload, (uint16, bytes, uint));
                            address to = toAddressBytes.toAddress(0);
                            amount = _creditTo(_srcChainId, to, amount);
                            emit ReceiveFromChain(_srcChainId, to, amount);
                        }
                        function _checkAdapterParams(uint16 _dstChainId, uint16 _pkType, bytes memory _adapterParams, uint _extraGas) internal virtual {
                            if (useCustomAdapterParams) {
                                _checkGasLimit(_dstChainId, _pkType, _adapterParams, _extraGas);
                            } else {
                                require(_adapterParams.length == 0, "OFTCore: _adapterParams must be empty.");
                            }
                        }
                        function _debitFrom(address _from, uint16 _dstChainId, bytes memory _toAddress, uint _amount) internal virtual returns(uint);
                        function _creditTo(uint16 _srcChainId, address _toAddress, uint _amount) internal virtual returns(uint);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Contract module that helps prevent reentrant calls to a function.
                     *
                     * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
                     * available, which can be applied to functions to make sure there are no nested
                     * (reentrant) calls to them.
                     *
                     * Note that because there is a single `nonReentrant` guard, functions marked as
                     * `nonReentrant` may not call one another. This can be worked around by making
                     * those functions `private`, and then adding `external` `nonReentrant` entry
                     * points to them.
                     *
                     * TIP: If you would like to learn more about reentrancy and alternative ways
                     * to protect against it, check out our blog post
                     * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
                     */
                    abstract contract ReentrancyGuard {
                        // Booleans are more expensive than uint256 or any type that takes up a full
                        // word because each write operation emits an extra SLOAD to first read the
                        // slot's contents, replace the bits taken up by the boolean, and then write
                        // back. This is the compiler's defense against contract upgrades and
                        // pointer aliasing, and it cannot be disabled.
                        // The values being non-zero value makes deployment a bit more expensive,
                        // but in exchange the refund on every call to nonReentrant will be lower in
                        // amount. Since refunds are capped to a percentage of the total
                        // transaction's gas, it is best to keep them low in cases like this one, to
                        // increase the likelihood of the full refund coming into effect.
                        uint256 private constant _NOT_ENTERED = 1;
                        uint256 private constant _ENTERED = 2;
                        uint256 private _status;
                        constructor() {
                            _status = _NOT_ENTERED;
                        }
                        /**
                         * @dev Prevents a contract from calling itself, directly or indirectly.
                         * Calling a `nonReentrant` function from another `nonReentrant`
                         * function is not supported. It is possible to prevent this from happening
                         * by making the `nonReentrant` function external, and making it call a
                         * `private` function that does the actual work.
                         */
                        modifier nonReentrant() {
                            _nonReentrantBefore();
                            _;
                            _nonReentrantAfter();
                        }
                        function _nonReentrantBefore() private {
                            // On the first call to nonReentrant, _status will be _NOT_ENTERED
                            require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
                            // Any calls to nonReentrant after this point will fail
                            _status = _ENTERED;
                        }
                        function _nonReentrantAfter() private {
                            // By storing the original value once again, a refund is triggered (see
                            // https://eips.ethereum.org/EIPS/eip-2200)
                            _status = _NOT_ENTERED;
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.8.0;
                    import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
                    import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
                    import "./IOFT.sol";
                    import "./OFTCore.sol";
                    // override decimal() function is needed
                    contract OFT is OFTCore, ERC20, IOFT {
                        constructor(string memory _name, string memory _symbol, address _lzEndpoint) ERC20(_name, _symbol) OFTCore(_lzEndpoint) {}
                        function supportsInterface(bytes4 interfaceId) public view virtual override(OFTCore, IERC165) returns (bool) {
                            return interfaceId == type(IOFT).interfaceId || interfaceId == type(IERC20).interfaceId || super.supportsInterface(interfaceId);
                        }
                        function token() public view virtual override returns (address) {
                            return address(this);
                        }
                        function circulatingSupply() public view virtual override returns (uint) {
                            return totalSupply();
                        }
                        function _debitFrom(address _from, uint16, bytes memory, uint _amount) internal virtual override returns(uint) {
                            address spender = _msgSender();
                            if (_from != spender) _spendAllowance(_from, spender, _amount);
                            _burn(_from, _amount);
                            return _amount;
                        }
                        function _creditTo(uint16, address _toAddress, uint _amount) internal virtual override returns(uint) {
                            _mint(_toAddress, _amount);
                            return _amount;
                        }
                    }
                    

                    File 3 of 9: OptimizedTransparentUpgradeableProxy
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    /**
                     * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
                     * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
                     * be specified by overriding the virtual {_implementation} function.
                     * 
                     * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
                     * different contract through the {_delegate} function.
                     * 
                     * The success and return data of the delegated call will be returned back to the caller of the proxy.
                     */
                    abstract contract Proxy {
                        /**
                         * @dev Delegates the current call to `implementation`.
                         * 
                         * This function does not return to its internall call site, it will return directly to the external caller.
                         */
                        function _delegate(address implementation) internal {
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                // Copy msg.data. We take full control of memory in this inline assembly
                                // block because it will not return to Solidity code. We overwrite the
                                // Solidity scratch pad at memory position 0.
                                calldatacopy(0, 0, calldatasize())
                                // Call the implementation.
                                // out and outsize are 0 because we don't know the size yet.
                                let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                                // Copy the returned data.
                                returndatacopy(0, 0, returndatasize())
                                switch result
                                // delegatecall returns 0 on error.
                                case 0 { revert(0, returndatasize()) }
                                default { return(0, returndatasize()) }
                            }
                        }
                        /**
                         * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
                         * and {_fallback} should delegate.
                         */
                        function _implementation() internal virtual view returns (address);
                        /**
                         * @dev Delegates the current call to the address returned by `_implementation()`.
                         * 
                         * This function does not return to its internall call site, it will return directly to the external caller.
                         */
                        function _fallback() internal {
                            _beforeFallback();
                            _delegate(_implementation());
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
                         * function in the contract matches the call data.
                         */
                        fallback () payable external {
                            _fallback();
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
                         * is empty.
                         */
                        receive () payable external {
                            _fallback();
                        }
                        /**
                         * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
                         * call, or as part of the Solidity `fallback` or `receive` functions.
                         * 
                         * If overriden should call `super._beforeFallback()`.
                         */
                        function _beforeFallback() internal virtual {
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "./Proxy.sol";
                    import "../utils/Address.sol";
                    /**
                     * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                     * implementation address that can be changed. This address is stored in storage in the location specified by
                     * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
                     * implementation behind the proxy.
                     * 
                     * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see
                     * {TransparentUpgradeableProxy}.
                     */
                    contract UpgradeableProxy is Proxy {
                        /**
                         * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
                         * 
                         * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
                         * function call, and allows initializating the storage of the proxy like a Solidity constructor.
                         */
                        constructor(address _logic, bytes memory _data) payable {
                            assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
                            _setImplementation(_logic);
                            if(_data.length > 0) {
                                // solhint-disable-next-line avoid-low-level-calls
                                (bool success,) = _logic.delegatecall(_data);
                                require(success);
                            }
                        }
                        /**
                         * @dev Emitted when the implementation is upgraded.
                         */
                        event Upgraded(address indexed implementation);
                        /**
                         * @dev Storage slot with the address of the current implementation.
                         * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                        /**
                         * @dev Returns the current implementation address.
                         */
                        function _implementation() internal override view returns (address impl) {
                            bytes32 slot = _IMPLEMENTATION_SLOT;
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                impl := sload(slot)
                            }
                        }
                        /**
                         * @dev Upgrades the proxy to a new implementation.
                         * 
                         * Emits an {Upgraded} event.
                         */
                        function _upgradeTo(address newImplementation) internal {
                            _setImplementation(newImplementation);
                            emit Upgraded(newImplementation);
                        }
                        /**
                         * @dev Stores a new address in the EIP1967 implementation slot.
                         */
                        function _setImplementation(address newImplementation) private {
                            require(Address.isContract(newImplementation), "UpgradeableProxy: new implementation is not a contract");
                            bytes32 slot = _IMPLEMENTATION_SLOT;
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                sstore(slot, newImplementation)
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    /**
                     * @dev Collection of functions related to the address type
                     */
                    library Address {
                        /**
                         * @dev Returns true if `account` is a contract.
                         *
                         * [IMPORTANT]
                         * ====
                         * It is unsafe to assume that an address for which this function returns
                         * false is an externally-owned account (EOA) and not a contract.
                         *
                         * Among others, `isContract` will return false for the following
                         * types of addresses:
                         *
                         *  - an externally-owned account
                         *  - a contract in construction
                         *  - an address where a contract will be created
                         *  - an address where a contract lived, but was destroyed
                         * ====
                         */
                        function isContract(address account) internal view returns (bool) {
                            // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
                            // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
                            // for accounts without code, i.e. `keccak256('')`
                            bytes32 codehash;
                            bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
                            // solhint-disable-next-line no-inline-assembly
                            assembly { codehash := extcodehash(account) }
                            return (codehash != accountHash && codehash != 0x0);
                        }
                        /**
                         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                         * `recipient`, forwarding all available gas and reverting on errors.
                         *
                         * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                         * of certain opcodes, possibly making contracts go over the 2300 gas limit
                         * imposed by `transfer`, making them unable to receive funds via
                         * `transfer`. {sendValue} removes this limitation.
                         *
                         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                         *
                         * IMPORTANT: because control is transferred to `recipient`, care must be
                         * taken to not create reentrancy vulnerabilities. Consider using
                         * {ReentrancyGuard} or the
                         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                         */
                        function sendValue(address payable recipient, uint256 amount) internal {
                            require(address(this).balance >= amount, "Address: insufficient balance");
                            // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
                            (bool success, ) = recipient.call{ value: amount }("");
                            require(success, "Address: unable to send value, recipient may have reverted");
                        }
                        /**
                         * @dev Performs a Solidity function call using a low level `call`. A
                         * plain`call` is an unsafe replacement for a function call: use this
                         * function instead.
                         *
                         * If `target` reverts with a revert reason, it is bubbled up by this
                         * function (like regular Solidity function calls).
                         *
                         * Returns the raw returned data. To convert to the expected return value,
                         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                         *
                         * Requirements:
                         *
                         * - `target` must be a contract.
                         * - calling `target` with `data` must not revert.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                          return functionCall(target, data, "Address: low-level call failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                         * `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
                            return _functionCallWithValue(target, data, 0, errorMessage);
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                         * but also transferring `value` wei to `target`.
                         *
                         * Requirements:
                         *
                         * - the calling contract must have an ETH balance of at least `value`.
                         * - the called Solidity function must be `payable`.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
                            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                         * with `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
                            require(address(this).balance >= value, "Address: insufficient balance for call");
                            return _functionCallWithValue(target, data, value, errorMessage);
                        }
                        function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
                            require(isContract(target), "Address: call to non-contract");
                            // solhint-disable-next-line avoid-low-level-calls
                            (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
                            if (success) {
                                return returndata;
                            } else {
                                // Look for revert reason and bubble it up if present
                                if (returndata.length > 0) {
                                    // The easiest way to bubble the revert reason is using memory via assembly
                                    // solhint-disable-next-line no-inline-assembly
                                    assembly {
                                        let returndata_size := mload(returndata)
                                        revert(add(32, returndata), returndata_size)
                                    }
                                } else {
                                    revert(errorMessage);
                                }
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "../openzeppelin/proxy/UpgradeableProxy.sol";
                    /**
                     * @dev This contract implements a proxy that is upgradeable by an admin.
                     *
                     * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
                     * clashing], which can potentially be used in an attack, this contract uses the
                     * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
                     * things that go hand in hand:
                     *
                     * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
                     * that call matches one of the admin functions exposed by the proxy itself.
                     * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
                     * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
                     * "admin cannot fallback to proxy target".
                     *
                     * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
                     * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
                     * to sudden errors when trying to call a function from the proxy implementation.
                     *
                     * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
                     * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.
                     */
                    contract OptimizedTransparentUpgradeableProxy is UpgradeableProxy {
                        address internal immutable _ADMIN;
                        /**
                         * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
                         * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.
                         */
                        constructor(
                            address initialLogic,
                            address initialAdmin,
                            bytes memory _data
                        ) payable UpgradeableProxy(initialLogic, _data) {
                            assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
                            bytes32 slot = _ADMIN_SLOT;
                            _ADMIN = initialAdmin;
                            // still store it to work with EIP-1967
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                sstore(slot, initialAdmin)
                            }
                        }
                        /**
                         * @dev Storage slot with the admin of the contract.
                         * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
                        /**
                         * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
                         */
                        modifier ifAdmin() {
                            if (msg.sender == _admin()) {
                                _;
                            } else {
                                _fallback();
                            }
                        }
                        /**
                         * @dev Returns the current admin.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
                         */
                        function admin() external ifAdmin returns (address) {
                            return _admin();
                        }
                        /**
                         * @dev Returns the current implementation.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
                         */
                        function implementation() external ifAdmin returns (address) {
                            return _implementation();
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
                         */
                        function upgradeTo(address newImplementation) external ifAdmin {
                            _upgradeTo(newImplementation);
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
                         * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
                         * proxied contract.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
                         */
                        function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
                            _upgradeTo(newImplementation);
                            // solhint-disable-next-line avoid-low-level-calls
                            (bool success, ) = newImplementation.delegatecall(data);
                            require(success);
                        }
                        /**
                         * @dev Returns the current admin.
                         */
                        function _admin() internal view returns (address adm) {
                            return _ADMIN;
                        }
                        /**
                         * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
                         */
                        function _beforeFallback() internal virtual override {
                            require(msg.sender != _admin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
                            super._beforeFallback();
                        }
                    }
                    

                    File 4 of 9: UltraLightNodeV2
                    {"Address.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        // solhint-disable-next-line no-inline-assembly\n        assembly { size := extcodesize(account) }\n        return size \u003e 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity\u0027s `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance \u003e= amount, \"Address: insufficient balance\");\n\n        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n        (bool success, ) = recipient.call{ value: amount }(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain`call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n      return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n        require(address(this).balance \u003e= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.call{ value: value }(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length \u003e 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                // solhint-disable-next-line no-inline-assembly\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"},"Buffer.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\n// https://github.com/ensdomains/buffer\n\npragma solidity ^0.7.0;\n\n/**\n * @dev A library for working with mutable byte buffers in Solidity.\n *\n * Byte buffers are mutable and expandable, and provide a variety of primitives\n * for writing to them. At any time you can fetch a bytes object containing the\n * current contents of the buffer. The bytes object should not be stored between\n * operations, as it may change due to resizing of the buffer.\n */\nlibrary Buffer {\n    /**\n     * @dev Represents a mutable buffer. Buffers have a current value (buf) and\n     *      a capacity. The capacity may be longer than the current value, in\n     *      which case it can be extended without the need to allocate more memory.\n     */\n    struct buffer {\n        bytes buf;\n        uint capacity;\n    }\n\n    /**\n     * @dev Initializes a buffer with an initial capacity.a co\n     * @param buf The buffer to initialize.\n     * @param capacity The number of bytes of space to allocate the buffer.\n     * @return The buffer, for chaining.\n     */\n    function init(buffer memory buf, uint capacity) internal pure returns (buffer memory) {\n        if (capacity % 32 != 0) {\n            capacity += 32 - (capacity % 32);\n        }\n        // Allocate space for the buffer data\n        buf.capacity = capacity;\n        assembly {\n            let ptr := mload(0x40)\n            mstore(buf, ptr)\n            mstore(ptr, 0)\n            mstore(0x40, add(32, add(ptr, capacity)))\n        }\n        return buf;\n    }\n\n\n    /**\n     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed\n     *      the capacity of the buffer.\n     * @param buf The buffer to append to.\n     * @param off The start offset to write to.\n     * @param rawData The data to append.\n     * @param len The number of bytes to copy.\n     * @return The original buffer, for chaining.\n     */\n    function writeRawBytes(\n        buffer memory buf,\n        uint off,\n        bytes memory rawData,\n        uint offData,\n        uint len\n    ) internal pure returns (buffer memory) {\n        if (off + len \u003e buf.capacity) {\n            resize(buf, max(buf.capacity, len + off) * 2);\n        }\n\n        uint dest;\n        uint src;\n        assembly {\n            // Memory address of the buffer data\n            let bufptr := mload(buf)\n            // Length of existing buffer data\n            let buflen := mload(bufptr)\n            // Start address = buffer address + offset + sizeof(buffer length)\n            dest := add(add(bufptr, 32), off)\n            // Update buffer length if we\u0027re extending it\n            if gt(add(len, off), buflen) {\n                mstore(bufptr, add(len, off))\n            }\n            src := add(rawData, offData)\n        }\n\n        // Copy word-length chunks while possible\n        for (; len \u003e= 32; len -= 32) {\n            assembly {\n                mstore(dest, mload(src))\n            }\n            dest += 32;\n            src += 32;\n        }\n\n        // Copy remaining bytes\n        uint mask = 256**(32 - len) - 1;\n        assembly {\n            let srcpart := and(mload(src), not(mask))\n            let destpart := and(mload(dest), mask)\n            mstore(dest, or(destpart, srcpart))\n        }\n\n        return buf;\n    }\n\n    /**\n     * @dev Writes a byte string to a buffer. Resizes if doing so would exceed\n     *      the capacity of the buffer.\n     * @param buf The buffer to append to.\n     * @param off The start offset to write to.\n     * @param data The data to append.\n     * @param len The number of bytes to copy.\n     * @return The original buffer, for chaining.\n     */\n    function write(buffer memory buf, uint off, bytes memory data, uint len) internal pure returns (buffer memory) {\n        require(len \u003c= data.length);\n\n        if (off + len \u003e buf.capacity) {\n            resize(buf, max(buf.capacity, len + off) * 2);\n        }\n\n        uint dest;\n        uint src;\n        assembly {\n        // Memory address of the buffer data\n            let bufptr := mload(buf)\n        // Length of existing buffer data\n            let buflen := mload(bufptr)\n        // Start address = buffer address + offset + sizeof(buffer length)\n            dest := add(add(bufptr, 32), off)\n        // Update buffer length if we\u0027re extending it\n            if gt(add(len, off), buflen) {\n                mstore(bufptr, add(len, off))\n            }\n            src := add(data, 32)\n        }\n\n        // Copy word-length chunks while possible\n        for (; len \u003e= 32; len -= 32) {\n            assembly {\n                mstore(dest, mload(src))\n            }\n            dest += 32;\n            src += 32;\n        }\n\n        // Copy remaining bytes\n        uint mask = 256**(32 - len) - 1;\n        assembly {\n            let srcpart := and(mload(src), not(mask))\n            let destpart := and(mload(dest), mask)\n            mstore(dest, or(destpart, srcpart))\n        }\n\n        return buf;\n    }\n\n    function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {\n        return write(buf, buf.buf.length, data, data.length);\n    }\n\n    function resize(buffer memory buf, uint capacity) private pure {\n        bytes memory oldbuf = buf.buf;\n        init(buf, capacity);\n        append(buf, oldbuf);\n    }\n\n    function max(uint a, uint b) private pure returns (uint) {\n        if (a \u003e b) {\n            return a;\n        }\n        return b;\n    }\n}\n"},"Context.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity \u003e=0.6.0 \u003c0.8.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with GSN meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address payable) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes memory) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        return msg.data;\n    }\n}\n"},"IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller\u0027s account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller\u0027s tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender\u0027s allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller\u0027s\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},"ILayerZeroEndpoint.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.5.0;\n\nimport \"./ILayerZeroUserApplicationConfig.sol\";\n\ninterface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {\n    // @notice send a LayerZero message to the specified address at a LayerZero endpoint.\n    // @param _dstChainId - the destination chain identifier\n    // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains\n    // @param _payload - a custom bytes payload to send to the destination contract\n    // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address\n    // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction\n    // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination\n    function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;\n\n    // @notice used by the messaging library to publish verified payload\n    // @param _srcChainId - the source chain identifier\n    // @param _srcAddress - the source contract (as bytes) at the source chain\n    // @param _dstAddress - the address on destination chain\n    // @param _nonce - the unbound message ordering nonce\n    // @param _gasLimit - the gas limit for external contract execution\n    // @param _payload - verified payload to send to the destination contract\n    function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;\n\n    // @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain\n    // @param _srcChainId - the source chain identifier\n    // @param _srcAddress - the source chain contract address\n    function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);\n\n    // @notice get the outboundNonce from this source chain which, consequently, is always an EVM\n    // @param _srcAddress - the source chain contract address\n    function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);\n\n    // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery\n    // @param _dstChainId - the destination chain identifier\n    // @param _userApplication - the user app address on this EVM chain\n    // @param _payload - the custom message to send over LayerZero\n    // @param _payInZRO - if false, user app pays the protocol fee in native token\n    // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain\n    function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);\n\n    // @notice get this Endpoint\u0027s immutable source identifier\n    function getChainId() external view returns (uint16);\n\n    // @notice the interface to retry failed message on this Endpoint destination\n    // @param _srcChainId - the source chain identifier\n    // @param _srcAddress - the source chain contract address\n    // @param _payload - the payload to be retried\n    function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;\n\n    // @notice query if any STORED payload (message blocking) at the endpoint.\n    // @param _srcChainId - the source chain identifier\n    // @param _srcAddress - the source chain contract address\n    function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);\n\n    // @notice query if the _libraryAddress is valid for sending msgs.\n    // @param _userApplication - the user app address on this EVM chain\n    function getSendLibraryAddress(address _userApplication) external view returns (address);\n\n    // @notice query if the _libraryAddress is valid for receiving msgs.\n    // @param _userApplication - the user app address on this EVM chain\n    function getReceiveLibraryAddress(address _userApplication) external view returns (address);\n\n    // @notice query if the non-reentrancy guard for send() is on\n    // @return true if the guard is on. false otherwise\n    function isSendingPayload() external view returns (bool);\n\n    // @notice query if the non-reentrancy guard for receive() is on\n    // @return true if the guard is on. false otherwise\n    function isReceivingPayload() external view returns (bool);\n\n    // @notice get the configuration of the LayerZero messaging library of the specified version\n    // @param _version - messaging library version\n    // @param _chainId - the chainId for the pending config change\n    // @param _userApplication - the contract address of the user application\n    // @param _configType - type of configuration. every messaging library has its own convention.\n    function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);\n\n    // @notice get the send() LayerZero messaging library version\n    // @param _userApplication - the contract address of the user application\n    function getSendVersion(address _userApplication) external view returns (uint16);\n\n    // @notice get the lzReceive() LayerZero messaging library version\n    // @param _userApplication - the contract address of the user application\n    function getReceiveVersion(address _userApplication) external view returns (uint16);\n}\n"},"ILayerZeroMessagingLibrary.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\n\nimport \"./ILayerZeroUserApplicationConfig.sol\";\n\ninterface ILayerZeroMessagingLibrary {\n    // send(), messages will be inflight.\n    function send(address _userApplication, uint64 _lastNonce, uint16 _chainId, bytes calldata _destination, bytes calldata _payload, address payable refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;\n\n    // estimate native fee at the send side\n    function estimateFees(uint16 _chainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);\n\n    //---------------------------------------------------------------------------\n    // setConfig / getConfig are User Application (UA) functions to specify Oracle, Relayer, blockConfirmations, libraryVersion\n    function setConfig(uint16 _chainId, address _userApplication, uint _configType, bytes calldata _config) external;\n\n    function getConfig(uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);\n}\n"},"ILayerZeroMessagingLibraryV2.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\n\nimport \"./ILayerZeroUserApplicationConfig.sol\";\nimport \"./ILayerZeroMessagingLibrary.sol\";\n\ninterface ILayerZeroMessagingLibraryV2 is ILayerZeroMessagingLibrary {\n    function getOutboundNonce(uint16 _chainId, bytes calldata _path) external view returns (uint64);\n}\n"},"ILayerZeroOracleV2.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\n\ninterface ILayerZeroOracleV2 {\n    // @notice query price and assign jobs at the same time\n    // @param _dstChainId - the destination endpoint identifier\n    // @param _outboundProofType - the proof type identifier to specify proof to be relayed\n    // @param _outboundBlockConfirmation - block confirmation delay before relaying blocks\n    // @param _userApplication - the source sending contract address\n    function assignJob(uint16 _dstChainId, uint16 _outboundProofType, uint64 _outboundBlockConfirmation, address _userApplication) external returns (uint price);\n\n    // @notice query the oracle price for relaying block information to the destination chain\n    // @param _dstChainId the destination endpoint identifier\n    // @param _outboundProofType the proof type identifier to specify the data to be relayed\n    // @param _outboundBlockConfirmation - block confirmation delay before relaying blocks\n    // @param _userApplication - the source sending contract address\n    function getFee(uint16 _dstChainId, uint16 _outboundProofType, uint64 _outboundBlockConfirmation, address _userApplication) external view returns (uint price);\n\n    // @notice withdraw the accrued fee in ultra light node\n    // @param _to - the fee receiver\n    // @param _amount - the withdrawal amount\n    function withdrawFee(address payable _to, uint _amount) external;\n}\n"},"ILayerZeroReceiver.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.5.0;\n\ninterface ILayerZeroReceiver {\n    // @notice LayerZero endpoint will invoke this function to deliver the message on the destination\n    // @param _srcChainId - the source endpoint identifier\n    // @param _srcAddress - the source sending contract address from the source chain\n    // @param _nonce - the ordered message nonce\n    // @param _payload - the signed payload is the UA bytes has encoded to be sent\n    function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;\n}\n"},"ILayerZeroRelayerV2.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\n\ninterface ILayerZeroRelayerV2 {\n    // @notice query price and assign jobs at the same time\n    // @param _dstChainId - the destination endpoint identifier\n    // @param _outboundProofType - the proof type identifier to specify proof to be relayed\n    // @param _userApplication - the source sending contract address. relayers may apply price discrimination to user apps\n    // @param _payloadSize - the length of the payload. it is an indicator of gas usage for relaying cross-chain messages\n    // @param _adapterParams - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain\n    function assignJob(uint16 _dstChainId, uint16 _outboundProofType, address _userApplication, uint _payloadSize, bytes calldata _adapterParams) external returns (uint price);\n\n    // @notice query the relayer price for relaying the payload and its proof to the destination chain\n    // @param _dstChainId - the destination endpoint identifier\n    // @param _outboundProofType - the proof type identifier to specify proof to be relayed\n    // @param _userApplication - the source sending contract address. relayers may apply price discrimination to user apps\n    // @param _payloadSize - the length of the payload. it is an indicator of gas usage for relaying cross-chain messages\n    // @param _adapterParams - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain\n    function getFee(uint16 _dstChainId, uint16 _outboundProofType, address _userApplication, uint _payloadSize, bytes calldata _adapterParams) external view returns (uint price);\n\n    // @notice withdraw the accrued fee in ultra light node\n    // @param _to - the fee receiver\n    // @param _amount - the withdrawal amount\n    function withdrawFee(address payable _to, uint _amount) external;\n}\n"},"ILayerZeroTreasury.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.5.0;\n\ninterface ILayerZeroTreasury {\n    function getFees(bool payInZro, uint relayerFee, uint oracleFee) external view returns (uint);\n}\n"},"ILayerZeroUltraLightNodeV2.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\npragma abicoder v2;\n\ninterface ILayerZeroUltraLightNodeV2 {\n    // Relayer functions\n    function validateTransactionProof(uint16 _srcChainId, address _dstAddress, uint _gasLimit, bytes32 _lookupHash, bytes32 _blockData, bytes calldata _transactionProof) external;\n\n    // an Oracle delivers the block data using updateHash()\n    function updateHash(uint16 _srcChainId, bytes32 _lookupHash, uint _confirmations, bytes32 _blockData) external;\n\n    // can only withdraw the receivable of the msg.sender\n    function withdrawNative(address payable _to, uint _amount) external;\n\n    function withdrawZRO(address _to, uint _amount) external;\n\n    // view functions\n    function getAppConfig(uint16 _remoteChainId, address _userApplicationAddress) external view returns (ApplicationConfiguration memory);\n\n    function accruedNativeFee(address _address) external view returns (uint);\n\n    struct ApplicationConfiguration {\n        uint16 inboundProofLibraryVersion;\n        uint64 inboundBlockConfirmations;\n        address relayer;\n        uint16 outboundProofType;\n        uint64 outboundBlockConfirmations;\n        address oracle;\n    }\n\n    event HashReceived(uint16 indexed srcChainId, address indexed oracle, bytes32 lookupHash, bytes32 blockData, uint confirmations);\n    event RelayerParams(bytes adapterParams, uint16 outboundProofType);\n    event Packet(bytes payload);\n    event InvalidDst(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);\n    event PacketReceived(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);\n    event AppConfigUpdated(address indexed userApplication, uint indexed configType, bytes newConfig);\n    event AddInboundProofLibraryForChain(uint16 indexed chainId, address lib);\n    event EnableSupportedOutboundProof(uint16 indexed chainId, uint16 proofType);\n    event SetChainAddressSize(uint16 indexed chainId, uint size);\n    event SetDefaultConfigForChainId(uint16 indexed chainId, uint16 inboundProofLib, uint64 inboundBlockConfirm, address relayer, uint16 outboundProofType, uint64 outboundBlockConfirm, address oracle);\n    event SetDefaultAdapterParamsForChainId(uint16 indexed chainId, uint16 indexed proofType, bytes adapterParams);\n    event SetLayerZeroToken(address indexed tokenAddress);\n    event SetRemoteUln(uint16 indexed chainId, bytes32 uln);\n    event SetTreasury(address indexed treasuryAddress);\n    event WithdrawZRO(address indexed msgSender, address indexed to, uint amount);\n    event WithdrawNative(address indexed msgSender, address indexed to, uint amount);\n}\n"},"ILayerZeroUserApplicationConfig.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.5.0;\n\ninterface ILayerZeroUserApplicationConfig {\n    // @notice set the configuration of the LayerZero messaging library of the specified version\n    // @param _version - messaging library version\n    // @param _chainId - the chainId for the pending config change\n    // @param _configType - type of configuration. every messaging library has its own convention.\n    // @param _config - configuration in the bytes. can encode arbitrary content.\n    function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;\n\n    // @notice set the send() LayerZero messaging library version to _version\n    // @param _version - new messaging library version\n    function setSendVersion(uint16 _version) external;\n\n    // @notice set the lzReceive() LayerZero messaging library version to _version\n    // @param _version - new messaging library version\n    function setReceiveVersion(uint16 _version) external;\n\n    // @notice Only when the UA needs to resume the message flow in blocking mode and clear the stored payload\n    // @param _srcChainId - the chainId of the source chain\n    // @param _srcAddress - the contract address of the source contract at the source chain\n    function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;\n}\n"},"ILayerZeroValidationLibrary.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity \u003e=0.7.0;\npragma abicoder v2;\n\nimport \"./LayerZeroPacket.sol\";\n\ninterface ILayerZeroValidationLibrary {\n    function validateProof(bytes32 blockData, bytes calldata _data, uint _remoteAddressSize) external returns (LayerZeroPacket.Packet memory packet);\n}\n"},"LayerZeroPacket.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity 0.7.6;\n\nimport \"./Buffer.sol\";\nimport \"./SafeMath.sol\";\n\nlibrary LayerZeroPacket {\n    using Buffer for Buffer.buffer;\n    using SafeMath for uint;\n\n    struct Packet {\n        uint16 srcChainId;\n        uint16 dstChainId;\n        uint64 nonce;\n        address dstAddress;\n        bytes srcAddress;\n        bytes32 ulnAddress;\n        bytes payload;\n    }\n\n    function getPacket(\n        bytes memory data,\n        uint16 srcChain,\n        uint sizeOfSrcAddress,\n        bytes32 ulnAddress\n    ) internal pure returns (LayerZeroPacket.Packet memory) {\n        uint16 dstChainId;\n        address dstAddress;\n        uint size;\n        uint64 nonce;\n\n        // The log consists of the destination chain id and then a bytes payload\n        //      0--------------------------------------------31\n        // 0   |  total bytes size\n        // 32  |  destination chain id\n        // 64  |  bytes offset\n        // 96  |  bytes array size\n        // 128 |  payload\n        assembly {\n            dstChainId := mload(add(data, 32))\n            size := mload(add(data, 96)) /// size of the byte array\n            nonce := mload(add(data, 104)) // offset to convert to uint64  128  is index -24\n            dstAddress := mload(add(data, sub(add(128, sizeOfSrcAddress), 4))) // offset to convert to address 12 -8\n        }\n\n        Buffer.buffer memory srcAddressBuffer;\n        srcAddressBuffer.init(sizeOfSrcAddress);\n        srcAddressBuffer.writeRawBytes(0, data, 136, sizeOfSrcAddress); // 128 + 8\n\n        uint payloadSize = size.sub(28).sub(sizeOfSrcAddress);\n        Buffer.buffer memory payloadBuffer;\n        payloadBuffer.init(payloadSize);\n        payloadBuffer.writeRawBytes(0, data, sizeOfSrcAddress.add(156), payloadSize); // 148 + 8\n        return LayerZeroPacket.Packet(srcChain, dstChainId, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);\n    }\n\n    function getPacketV2(\n        bytes memory data,\n        uint sizeOfSrcAddress,\n        bytes32 ulnAddress\n    ) internal pure returns (LayerZeroPacket.Packet memory) {\n        // packet def: abi.encodePacked(nonce, srcChain, srcAddress, dstChain, dstAddress, payload);\n        // data def: abi.encode(packet) = offset(32) + length(32) + packet\n        //              if from EVM\n        // 0 - 31       0 - 31          |  total bytes size\n        // 32 - 63      32 - 63         |  location\n        // 64 - 95      64 - 95         |  size of the packet\n        // 96 - 103     96 - 103        |  nonce\n        // 104 - 105    104 - 105       |  srcChainId\n        // 106 - P      106 - 125       |  srcAddress, where P = 106 + sizeOfSrcAddress - 1,\n        // P+1 - P+2    126 - 127       |  dstChainId\n        // P+3 - P+22   128 - 147       |  dstAddress\n        // P+23 - END   148 - END       |  payload\n\n        // decode the packet\n        uint256 realSize;\n        uint64 nonce;\n        uint16 srcChain;\n        uint16 dstChain;\n        address dstAddress;\n        assembly {\n            realSize := mload(add(data, 64))\n            nonce := mload(add(data, 72)) // 104 - 32\n            srcChain := mload(add(data, 74)) // 106 - 32\n            dstChain := mload(add(data, add(76, sizeOfSrcAddress))) // P + 3 - 32 = 105 + size + 3 - 32 = 76 + size\n            dstAddress := mload(add(data, add(96, sizeOfSrcAddress))) // P + 23 - 32 = 105 + size + 23 - 32 = 96 + size\n        }\n\n        require(srcChain != 0, \"LayerZeroPacket: invalid packet\");\n\n        Buffer.buffer memory srcAddressBuffer;\n        srcAddressBuffer.init(sizeOfSrcAddress);\n        srcAddressBuffer.writeRawBytes(0, data, 106, sizeOfSrcAddress);\n\n        uint nonPayloadSize = sizeOfSrcAddress.add(32);// 2 + 2 + 8 + 20, 32 + 20 = 52 if sizeOfSrcAddress == 20\n        uint payloadSize = realSize.sub(nonPayloadSize);\n        Buffer.buffer memory payloadBuffer;\n        payloadBuffer.init(payloadSize);\n        payloadBuffer.writeRawBytes(0, data, nonPayloadSize.add(96), payloadSize);\n\n        return LayerZeroPacket.Packet(srcChain, dstChain, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);\n    }\n\n    function getPacketV3(\n        bytes memory data,\n        uint sizeOfSrcAddress,\n        bytes32 ulnAddress\n    ) internal pure returns (LayerZeroPacket.Packet memory) {\n        // data def: abi.encodePacked(nonce, srcChain, srcAddress, dstChain, dstAddress, payload);\n        //              if from EVM\n        // 0 - 31       0 - 31          |  total bytes size\n        // 32 - 39      32 - 39         |  nonce\n        // 40 - 41      40 - 41         |  srcChainId\n        // 42 - P       42 - 61         |  srcAddress, where P = 41 + sizeOfSrcAddress,\n        // P+1 - P+2    62 - 63         |  dstChainId\n        // P+3 - P+22   64 - 83         |  dstAddress\n        // P+23 - END   84 - END        |  payload\n\n        // decode the packet\n        uint256 realSize = data.length;\n        uint nonPayloadSize = sizeOfSrcAddress.add(32);// 2 + 2 + 8 + 20, 32 + 20 = 52 if sizeOfSrcAddress == 20\n        require(realSize \u003e= nonPayloadSize, \"LayerZeroPacket: invalid packet\");\n        uint payloadSize = realSize - nonPayloadSize;\n\n        uint64 nonce;\n        uint16 srcChain;\n        uint16 dstChain;\n        address dstAddress;\n        assembly {\n            nonce := mload(add(data, 8)) // 40 - 32\n            srcChain := mload(add(data, 10)) // 42 - 32\n            dstChain := mload(add(data, add(12, sizeOfSrcAddress))) // P + 3 - 32 = 41 + size + 3 - 32 = 12 + size\n            dstAddress := mload(add(data, add(32, sizeOfSrcAddress))) // P + 23 - 32 = 41 + size + 23 - 32 = 32 + size\n        }\n\n        require(srcChain != 0, \"LayerZeroPacket: invalid packet\");\n\n        Buffer.buffer memory srcAddressBuffer;\n        srcAddressBuffer.init(sizeOfSrcAddress);\n        srcAddressBuffer.writeRawBytes(0, data, 42, sizeOfSrcAddress);\n\n        Buffer.buffer memory payloadBuffer;\n        if (payloadSize \u003e 0) {\n            payloadBuffer.init(payloadSize);\n            payloadBuffer.writeRawBytes(0, data, nonPayloadSize.add(32), payloadSize);\n        }\n\n        return LayerZeroPacket.Packet(srcChain, dstChain, nonce, dstAddress, srcAddressBuffer.buf, ulnAddress, payloadBuffer.buf);\n    }\n}\n"},"NonceContract.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity 0.7.6;\n\nimport \"./ILayerZeroEndpoint.sol\";\n\ncontract NonceContract {\n    ILayerZeroEndpoint public immutable endpoint;\n    // outboundNonce = [dstChainId][remoteAddress + localAddress]\n    mapping(uint16 =\u003e mapping(bytes =\u003e uint64)) public outboundNonce;\n\n    constructor(address _endpoint) {\n        endpoint = ILayerZeroEndpoint(_endpoint);\n    }\n\n    function increment(uint16 _chainId, address _ua, bytes calldata _path) external returns (uint64) {\n        require(endpoint.getSendLibraryAddress(_ua) == msg.sender, \"NonceContract: msg.sender is not valid sendlibrary\");\n        return ++outboundNonce[_chainId][_path];\n    }\n}\n"},"Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./Context.sol\";\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor () {\n        address msgSender = _msgSender();\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        emit OwnershipTransferred(_owner, address(0));\n        _owner = address(0);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n}\n"},"ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot\u0027s contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler\u0027s defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction\u0027s gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant _NOT_ENTERED = 1;\n    uint256 private constant _ENTERED = 2;\n\n    uint256 private _status;\n\n    constructor () {\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and make it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        // On the first call to nonReentrant, _notEntered will be true\n        require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n\n        _;\n\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = _NOT_ENTERED;\n    }\n}\n"},"SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./IERC20.sol\";\nimport \"./SafeMath.sol\";\nimport \"./Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using SafeMath for uint256;\n    using Address for address;\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // \u0027safeIncreaseAllowance\u0027 and \u0027safeDecreaseAllowance\u0027\n        // solhint-disable-next-line max-line-length\n        require((value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).add(value);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).sub(value, \"SafeERC20: decreased allowance below zero\");\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity\u0027s return data size checking mechanism, since\n        // we\u0027re implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        if (returndata.length \u003e 0) { // Return data is optional\n            // solhint-disable-next-line max-line-length\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"},"SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Wrappers over Solidity\u0027s arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it\u0027s recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        uint256 c = a + b;\n        if (c \u003c a) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b \u003e a) return (false, 0);\n        return (true, a - b);\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        // Gas optimization: this is cheaper than requiring \u0027a\u0027 not being zero, but the\n        // benefit is lost if \u0027b\u0027 is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) return (true, 0);\n        uint256 c = a * b;\n        if (c / a != b) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a / b);\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a % b);\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity\u0027s `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c \u003e= a, \"SafeMath: addition overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity\u0027s `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b \u003c= a, \"SafeMath: subtraction overflow\");\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity\u0027s `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == 0) return 0;\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b \u003e 0, \"SafeMath: division by zero\");\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b \u003e 0, \"SafeMath: modulo by zero\");\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity\u0027s `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b \u003c= a, errorMessage);\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\n     *\n     * Counterpart to Solidity\u0027s `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b \u003e 0, errorMessage);\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity\u0027s `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b \u003e 0, errorMessage);\n        return a % b;\n    }\n}\n"},"UltraLightNodeV2.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\n\npragma solidity 0.7.6;\npragma abicoder v2;\n\nimport \"./Ownable.sol\";\nimport \"./SafeMath.sol\";\nimport \"./ReentrancyGuard.sol\";\nimport \"./IERC20.sol\";\nimport \"./SafeERC20.sol\";\n\nimport \"./ILayerZeroValidationLibrary.sol\";\nimport \"./ILayerZeroReceiver.sol\";\nimport \"./ILayerZeroTreasury.sol\";\nimport \"./ILayerZeroEndpoint.sol\";\n// v2\nimport \"./ILayerZeroMessagingLibraryV2.sol\";\nimport \"./ILayerZeroOracleV2.sol\";\nimport \"./ILayerZeroUltraLightNodeV2.sol\";\nimport \"./ILayerZeroRelayerV2.sol\";\nimport \"./NonceContract.sol\";\n\ncontract UltraLightNodeV2 is ILayerZeroMessagingLibraryV2, ILayerZeroUltraLightNodeV2, ReentrancyGuard, Ownable {\n    using SafeERC20 for IERC20;\n    using SafeMath for uint;\n\n    // Application config\n    uint public constant CONFIG_TYPE_INBOUND_PROOF_LIBRARY_VERSION = 1;\n    uint public constant CONFIG_TYPE_INBOUND_BLOCK_CONFIRMATIONS = 2;\n    uint public constant CONFIG_TYPE_RELAYER = 3;\n    uint public constant CONFIG_TYPE_OUTBOUND_PROOF_TYPE = 4;\n    uint public constant CONFIG_TYPE_OUTBOUND_BLOCK_CONFIRMATIONS = 5;\n    uint public constant CONFIG_TYPE_ORACLE = 6;\n\n    // Token and Contracts\n    IERC20 public layerZeroToken;\n    ILayerZeroTreasury public treasuryContract;\n\n    mapping(address =\u003e uint) public nativeFees;\n    uint public treasuryZROFees;\n\n    // User Application\n    mapping(address =\u003e mapping(uint16 =\u003e ApplicationConfiguration)) public appConfig; // app address =\u003e chainId =\u003e config\n    mapping(uint16 =\u003e ApplicationConfiguration) public defaultAppConfig; // default UA settings if no version specified\n    mapping(uint16 =\u003e mapping(uint16 =\u003e bytes)) public defaultAdapterParams;\n\n    // Validation\n    mapping(uint16 =\u003e mapping(uint16 =\u003e address)) public inboundProofLibrary; // chainId =\u003e library Id =\u003e inboundProofLibrary contract\n    mapping(uint16 =\u003e uint16) public maxInboundProofLibrary; // chainId =\u003e inboundProofLibrary\n    mapping(uint16 =\u003e mapping(uint16 =\u003e bool)) public supportedOutboundProof; // chainId =\u003e outboundProofType =\u003e enabled\n    mapping(uint16 =\u003e uint) public chainAddressSizeMap;\n    mapping(address =\u003e mapping(uint16 =\u003e mapping(bytes32 =\u003e mapping(bytes32 =\u003e uint)))) public hashLookup; //[oracle][srcChainId][blockhash][datahash] -\u003e confirmation\n    mapping(uint16 =\u003e bytes32) public ulnLookup; // remote ulns\n\n    ILayerZeroEndpoint public immutable endpoint;\n    uint16 public immutable localChainId;\n    NonceContract public immutable nonceContract;\n\n    constructor(address _endpoint, address _nonceContract, uint16 _localChainId) {\n        require(_endpoint != address(0x0), \"LayerZero: endpoint cannot be zero address\");\n        require(_nonceContract != address(0x0), \"LayerZero: nonceContract cannot be zero address\");\n        ILayerZeroEndpoint lzEndpoint = ILayerZeroEndpoint(_endpoint);\n        localChainId = _localChainId;\n        endpoint = lzEndpoint;\n        nonceContract = NonceContract(_nonceContract);\n    }\n\n    // only the endpoint can call SEND() and setConfig()\n    modifier onlyEndpoint() {\n        require(address(endpoint) == msg.sender, \"LayerZero: only endpoint\");\n        _;\n    }\n\n    //----------------------------------------------------------------------------------\n    // PROTOCOL\n    function validateTransactionProof(uint16 _srcChainId, address _dstAddress, uint _gasLimit, bytes32 _lookupHash, bytes32 _blockData, bytes calldata _transactionProof) external override {\n        // retrieve UA\u0027s configuration using the _dstAddress from arguments.\n        ApplicationConfiguration memory uaConfig = _getAppConfig(_srcChainId, _dstAddress);\n\n        // assert that the caller == UA\u0027s relayer\n        require(uaConfig.relayer == msg.sender, \"LayerZero: invalid relayer\");\n\n        LayerZeroPacket.Packet memory _packet;\n        uint remoteAddressSize = chainAddressSizeMap[_srcChainId];\n        require(remoteAddressSize != 0, \"LayerZero: incorrect remote address size\");\n        {\n            // assert that the data submitted by UA\u0027s oracle have no fewer confirmations than UA\u0027s configuration\n            uint storedConfirmations = hashLookup[uaConfig.oracle][_srcChainId][_lookupHash][_blockData];\n            require(storedConfirmations \u003e 0 \u0026\u0026 storedConfirmations \u003e= uaConfig.inboundBlockConfirmations, \"LayerZero: not enough block confirmations\");\n\n            // decode\n            address inboundProofLib = inboundProofLibrary[_srcChainId][uaConfig.inboundProofLibraryVersion];\n            _packet = ILayerZeroValidationLibrary(inboundProofLib).validateProof(_blockData, _transactionProof, remoteAddressSize);\n        }\n\n        // packet content assertion\n        require(ulnLookup[_srcChainId] == _packet.ulnAddress \u0026\u0026 _packet.ulnAddress != bytes32(0), \"LayerZero: invalid _packet.ulnAddress\");\n        require(_packet.srcChainId == _srcChainId, \"LayerZero: invalid srcChain Id\");\n        // failsafe because the remoteAddress size being passed into validateProof trims the address this should not hit\n        require(_packet.srcAddress.length == remoteAddressSize, \"LayerZero: invalid srcAddress size\");\n        require(_packet.dstChainId == localChainId, \"LayerZero: invalid dstChain Id\");\n        require(_packet.dstAddress == _dstAddress, \"LayerZero: invalid dstAddress\");\n\n        // if the dst is not a contract, then emit and return early. This will break inbound nonces, but this particular\n        // path is already broken and wont ever be able to deliver anyways\n        if (!_isContract(_dstAddress)) {\n            emit InvalidDst(_packet.srcChainId, _packet.srcAddress, _packet.dstAddress, _packet.nonce, keccak256(_packet.payload));\n            return;\n        }\n\n        bytes memory pathData = abi.encodePacked(_packet.srcAddress, _packet.dstAddress);\n        emit PacketReceived(_packet.srcChainId, _packet.srcAddress, _packet.dstAddress, _packet.nonce, keccak256(_packet.payload));\n        endpoint.receivePayload(_srcChainId, pathData, _dstAddress, _packet.nonce, _gasLimit, _packet.payload);\n    }\n\n    function send(address _ua, uint64, uint16 _dstChainId, bytes calldata _path, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable override onlyEndpoint {\n        address ua = _ua;\n        uint16 dstChainId = _dstChainId;\n        require(ulnLookup[dstChainId] != bytes32(0), \"LayerZero: dstChainId does not exist\");\n\n        bytes memory dstAddress;\n        uint64 nonce;\n        // code block for solving \u0027Stack Too Deep\u0027\n        {\n            uint chainAddressSize = chainAddressSizeMap[dstChainId];\n            // path = remoteAddress + localAddress\n            require(chainAddressSize != 0 \u0026\u0026 _path.length == 20 + chainAddressSize, \"LayerZero: incorrect remote address size\");\n            address srcInPath;\n            bytes memory path = _path; // copy to memory\n            assembly {\n                srcInPath := mload(add(add(path, 20), chainAddressSize)) // chainAddressSize + 20\n            }\n            require(ua == srcInPath, \"LayerZero: wrong path data\");\n            dstAddress = _path[0:chainAddressSize];\n            nonce = nonceContract.increment(dstChainId, ua, path);\n        }\n\n        bytes memory payload = _payload;\n        ApplicationConfiguration memory uaConfig = _getAppConfig(dstChainId, ua);\n\n        // compute all the fees\n        uint relayerFee = _handleRelayer(dstChainId, uaConfig, ua, payload.length, _adapterParams);\n        uint oracleFee = _handleOracle(dstChainId, uaConfig, ua);\n        uint nativeProtocolFee = _handleProtocolFee(relayerFee, oracleFee, ua, _zroPaymentAddress);\n\n        // total native fee, does not include ZRO protocol fee\n        uint totalNativeFee = relayerFee.add(oracleFee).add(nativeProtocolFee);\n\n        // assert the user has attached enough native token for this address\n        require(totalNativeFee \u003c= msg.value, \"LayerZero: not enough native for fees\");\n        // refund if they send too much\n        uint amount = msg.value.sub(totalNativeFee);\n        if (amount \u003e 0) {\n            (bool success, ) = _refundAddress.call{value: amount}(\"\");\n            require(success, \"LayerZero: failed to refund\");\n        }\n\n        // emit the data packet\n        bytes memory encodedPayload = abi.encodePacked(nonce, localChainId, ua, dstChainId, dstAddress, payload);\n        emit Packet(encodedPayload);\n    }\n\n    function _handleRelayer(uint16 _dstChainId, ApplicationConfiguration memory _uaConfig, address _ua, uint _payloadSize, bytes memory _adapterParams) internal returns (uint relayerFee) {\n        if (_adapterParams.length == 0) {\n            _adapterParams = defaultAdapterParams[_dstChainId][_uaConfig.outboundProofType];\n        }\n        address relayerAddress = _uaConfig.relayer;\n        ILayerZeroRelayerV2 relayer = ILayerZeroRelayerV2(relayerAddress);\n        relayerFee = relayer.assignJob(_dstChainId, _uaConfig.outboundProofType, _ua, _payloadSize, _adapterParams);\n\n        _creditNativeFee(relayerAddress, relayerFee);\n\n        // emit the param events\n        emit RelayerParams(_adapterParams, _uaConfig.outboundProofType);\n    }\n\n    function _handleOracle(uint16 _dstChainId, ApplicationConfiguration memory _uaConfig, address _ua) internal returns (uint oracleFee) {\n        address oracleAddress = _uaConfig.oracle;\n        oracleFee = ILayerZeroOracleV2(oracleAddress).assignJob(_dstChainId, _uaConfig.outboundProofType, _uaConfig.outboundBlockConfirmations, _ua);\n\n        _creditNativeFee(oracleAddress, oracleFee);\n    }\n\n    function _handleProtocolFee(uint _relayerFee, uint _oracleFee, address _ua, address _zroPaymentAddress) internal returns (uint protocolNativeFee) {\n        // if no ZRO token or not specifying a payment address, pay in native token\n        bool payInNative = _zroPaymentAddress == address(0x0) || address(layerZeroToken) == address(0x0);\n        uint protocolFee = treasuryContract.getFees(!payInNative, _relayerFee, _oracleFee);\n\n        if (protocolFee \u003e 0) {\n            if (payInNative) {\n                address treasuryAddress = address(treasuryContract);\n                _creditNativeFee(treasuryAddress, protocolFee);\n                protocolNativeFee = protocolFee;\n            } else {\n                // zro payment address must equal the ua or the tx.origin otherwise the transaction reverts\n                require(_zroPaymentAddress == _ua || _zroPaymentAddress == tx.origin, \"LayerZero: must be paid by sender or origin\");\n\n                // transfer the LayerZero token to this contract from the payee\n                layerZeroToken.safeTransferFrom(_zroPaymentAddress, address(this), protocolFee);\n\n                treasuryZROFees = treasuryZROFees.add(protocolFee);\n            }\n        }\n    }\n\n    function _creditNativeFee(address _receiver, uint _amount) internal {\n        nativeFees[_receiver] = nativeFees[_receiver].add(_amount);\n    }\n\n    // Can be called by any address to update a block header\n    // can only upload new block data or the same block data with more confirmations\n    function updateHash(uint16 _srcChainId, bytes32 _lookupHash, uint _confirmations, bytes32 _blockData) external override {\n        uint storedConfirmations = hashLookup[msg.sender][_srcChainId][_lookupHash][_blockData];\n\n        // if it has a record, requires a larger confirmation.\n        require(storedConfirmations \u003c _confirmations, \"LayerZero: oracle data can only update if it has more confirmations\");\n\n        // set the new information into storage\n        hashLookup[msg.sender][_srcChainId][_lookupHash][_blockData] = _confirmations;\n\n        emit HashReceived(_srcChainId, msg.sender, _lookupHash, _blockData, _confirmations);\n    }\n\n    //----------------------------------------------------------------------------------\n    // Other Library Interfaces\n\n    // default to DEFAULT setting if ZERO value\n    function getAppConfig(uint16 _remoteChainId, address _ua) external view override returns (ApplicationConfiguration memory) {\n        return _getAppConfig(_remoteChainId, _ua);\n    }\n\n    function _getAppConfig(uint16 _remoteChainId, address _ua) internal view returns (ApplicationConfiguration memory) {\n        ApplicationConfiguration memory config = appConfig[_ua][_remoteChainId];\n        ApplicationConfiguration storage defaultConfig = defaultAppConfig[_remoteChainId];\n\n        if (config.inboundProofLibraryVersion == 0) {\n            config.inboundProofLibraryVersion = defaultConfig.inboundProofLibraryVersion;\n        }\n\n        if (config.inboundBlockConfirmations == 0) {\n            config.inboundBlockConfirmations = defaultConfig.inboundBlockConfirmations;\n        }\n\n        if (config.relayer == address(0x0)) {\n            config.relayer = defaultConfig.relayer;\n        }\n\n        if (config.outboundProofType == 0) {\n            config.outboundProofType = defaultConfig.outboundProofType;\n        }\n\n        if (config.outboundBlockConfirmations == 0) {\n            config.outboundBlockConfirmations = defaultConfig.outboundBlockConfirmations;\n        }\n\n        if (config.oracle == address(0x0)) {\n            config.oracle = defaultConfig.oracle;\n        }\n\n        return config;\n    }\n\n    function setConfig(uint16 _remoteChainId, address _ua, uint _configType, bytes calldata _config) external override onlyEndpoint {\n        ApplicationConfiguration storage uaConfig = appConfig[_ua][_remoteChainId];\n        if (_configType == CONFIG_TYPE_INBOUND_PROOF_LIBRARY_VERSION) {\n            uint16 inboundProofLibraryVersion = abi.decode(_config, (uint16));\n            require(inboundProofLibraryVersion \u003c= maxInboundProofLibrary[_remoteChainId], \"LayerZero: invalid inbound proof library version\");\n            uaConfig.inboundProofLibraryVersion = inboundProofLibraryVersion;\n        } else if (_configType == CONFIG_TYPE_INBOUND_BLOCK_CONFIRMATIONS) {\n            uint64 blockConfirmations = abi.decode(_config, (uint64));\n            uaConfig.inboundBlockConfirmations = blockConfirmations;\n        } else if (_configType == CONFIG_TYPE_RELAYER) {\n            address relayer = abi.decode(_config, (address));\n            uaConfig.relayer = relayer;\n        } else if (_configType == CONFIG_TYPE_OUTBOUND_PROOF_TYPE) {\n            uint16 outboundProofType = abi.decode(_config, (uint16));\n            require(supportedOutboundProof[_remoteChainId][outboundProofType] || outboundProofType == 0, \"LayerZero: invalid outbound proof type\");\n            uaConfig.outboundProofType = outboundProofType;\n        } else if (_configType == CONFIG_TYPE_OUTBOUND_BLOCK_CONFIRMATIONS) {\n            uint64 blockConfirmations = abi.decode(_config, (uint64));\n            uaConfig.outboundBlockConfirmations = blockConfirmations;\n        } else if (_configType == CONFIG_TYPE_ORACLE) {\n            address oracle = abi.decode(_config, (address));\n            uaConfig.oracle = oracle;\n        } else {\n            revert(\"LayerZero: Invalid config type\");\n        }\n\n        emit AppConfigUpdated(_ua, _configType, _config);\n    }\n\n    function getConfig(uint16 _remoteChainId, address _ua, uint _configType) external view override returns (bytes memory) {\n        ApplicationConfiguration storage uaConfig = appConfig[_ua][_remoteChainId];\n\n        if (_configType == CONFIG_TYPE_INBOUND_PROOF_LIBRARY_VERSION) {\n            if (uaConfig.inboundProofLibraryVersion == 0) {\n                return abi.encode(defaultAppConfig[_remoteChainId].inboundProofLibraryVersion);\n            }\n            return abi.encode(uaConfig.inboundProofLibraryVersion);\n        } else if (_configType == CONFIG_TYPE_INBOUND_BLOCK_CONFIRMATIONS) {\n            if (uaConfig.inboundBlockConfirmations == 0) {\n                return abi.encode(defaultAppConfig[_remoteChainId].inboundBlockConfirmations);\n            }\n            return abi.encode(uaConfig.inboundBlockConfirmations);\n        } else if (_configType == CONFIG_TYPE_RELAYER) {\n            if (uaConfig.relayer == address(0x0)) {\n                return abi.encode(defaultAppConfig[_remoteChainId].relayer);\n            }\n            return abi.encode(uaConfig.relayer);\n        } else if (_configType == CONFIG_TYPE_OUTBOUND_PROOF_TYPE) {\n            if (uaConfig.outboundProofType == 0) {\n                return abi.encode(defaultAppConfig[_remoteChainId].outboundProofType);\n            }\n            return abi.encode(uaConfig.outboundProofType);\n        } else if (_configType == CONFIG_TYPE_OUTBOUND_BLOCK_CONFIRMATIONS) {\n            if (uaConfig.outboundBlockConfirmations == 0) {\n                return abi.encode(defaultAppConfig[_remoteChainId].outboundBlockConfirmations);\n            }\n            return abi.encode(uaConfig.outboundBlockConfirmations);\n        } else if (_configType == CONFIG_TYPE_ORACLE) {\n            if (uaConfig.oracle == address(0x0)) {\n                return abi.encode(defaultAppConfig[_remoteChainId].oracle);\n            }\n            return abi.encode(uaConfig.oracle);\n        } else {\n            revert(\"LayerZero: Invalid config type\");\n        }\n    }\n\n    // returns the native fee the UA pays to cover fees\n    function estimateFees(uint16 _dstChainId, address _ua, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParams) external view override returns (uint nativeFee, uint zroFee) {\n        ApplicationConfiguration memory uaConfig = _getAppConfig(_dstChainId, _ua);\n\n        // Relayer Fee\n        bytes memory adapterParams;\n        if (_adapterParams.length \u003e 0) {\n            adapterParams = _adapterParams;\n        } else {\n            adapterParams = defaultAdapterParams[_dstChainId][uaConfig.outboundProofType];\n        }\n        uint relayerFee = ILayerZeroRelayerV2(uaConfig.relayer).getFee(_dstChainId, uaConfig.outboundProofType, _ua, _payload.length, adapterParams);\n\n        // Oracle Fee\n        address ua = _ua; // stack too deep\n        uint oracleFee = ILayerZeroOracleV2(uaConfig.oracle).getFee(_dstChainId, uaConfig.outboundProofType, uaConfig.outboundBlockConfirmations, ua);\n\n        // LayerZero Fee\n        uint protocolFee = treasuryContract.getFees(_payInZRO, relayerFee, oracleFee);\n        _payInZRO ? zroFee = protocolFee : nativeFee = protocolFee;\n\n        // return the sum of fees\n        nativeFee = nativeFee.add(relayerFee).add(oracleFee);\n    }\n\n    //---------------------------------------------------------------------------\n    // Claim Fees\n\n    // universal withdraw ZRO token function\n    function withdrawZRO(address _to, uint _amount) external override nonReentrant {\n        require(msg.sender == address(treasuryContract), \"LayerZero: only treasury\");\n        treasuryZROFees = treasuryZROFees.sub(_amount);\n        layerZeroToken.safeTransfer(_to, _amount);\n        emit WithdrawZRO(msg.sender, _to, _amount);\n    }\n\n    // universal withdraw native token function.\n    // the source contract should perform all the authentication control\n    function withdrawNative(address payable _to, uint _amount) external override nonReentrant {\n        require(_to != address(0x0), \"LayerZero: _to cannot be zero address\");\n        nativeFees[msg.sender] = nativeFees[msg.sender].sub(_amount);\n\n        (bool success, ) = _to.call{value: _amount}(\"\");\n        require(success, \"LayerZero: withdraw failed\");\n        emit WithdrawNative(msg.sender, _to, _amount);\n    }\n\n    //---------------------------------------------------------------------------\n    // Owner calls, configuration only.\n    function setLayerZeroToken(address _layerZeroToken) external onlyOwner {\n        require(_layerZeroToken != address(0x0), \"LayerZero: _layerZeroToken cannot be zero address\");\n        layerZeroToken = IERC20(_layerZeroToken);\n        emit SetLayerZeroToken(_layerZeroToken);\n    }\n\n    function setTreasury(address _treasury) external onlyOwner {\n        require(_treasury != address(0x0), \"LayerZero: treasury cannot be zero address\");\n        treasuryContract = ILayerZeroTreasury(_treasury);\n        emit SetTreasury(_treasury);\n    }\n\n    function addInboundProofLibraryForChain(uint16 _chainId, address _library) external onlyOwner {\n        require(_library != address(0x0), \"LayerZero: library cannot be zero address\");\n        uint16 libId = maxInboundProofLibrary[_chainId];\n        require(libId \u003c 65535, \"LayerZero: can not add new library\");\n        maxInboundProofLibrary[_chainId] = ++libId;\n        inboundProofLibrary[_chainId][libId] = _library;\n        emit AddInboundProofLibraryForChain(_chainId, _library);\n    }\n\n    function enableSupportedOutboundProof(uint16 _chainId, uint16 _proofType) external onlyOwner {\n        supportedOutboundProof[_chainId][_proofType] = true;\n        emit EnableSupportedOutboundProof(_chainId, _proofType);\n    }\n\n    function setDefaultConfigForChainId(uint16 _chainId, uint16 _inboundProofLibraryVersion, uint64 _inboundBlockConfirmations, address _relayer, uint16 _outboundProofType, uint64 _outboundBlockConfirmations, address _oracle) external onlyOwner {\n        require(_inboundProofLibraryVersion \u003c= maxInboundProofLibrary[_chainId] \u0026\u0026 _inboundProofLibraryVersion \u003e 0, \"LayerZero: invalid inbound proof library version\");\n        require(_inboundBlockConfirmations \u003e 0, \"LayerZero: invalid inbound block confirmation\");\n        require(_relayer != address(0x0), \"LayerZero: invalid relayer address\");\n        require(supportedOutboundProof[_chainId][_outboundProofType], \"LayerZero: invalid outbound proof type\");\n        require(_outboundBlockConfirmations \u003e 0, \"LayerZero: invalid outbound block confirmation\");\n        require(_oracle != address(0x0), \"LayerZero: invalid oracle address\");\n        defaultAppConfig[_chainId] = ApplicationConfiguration(_inboundProofLibraryVersion, _inboundBlockConfirmations, _relayer, _outboundProofType, _outboundBlockConfirmations, _oracle);\n        emit SetDefaultConfigForChainId(_chainId, _inboundProofLibraryVersion, _inboundBlockConfirmations, _relayer, _outboundProofType, _outboundBlockConfirmations, _oracle);\n    }\n\n    function setDefaultAdapterParamsForChainId(uint16 _chainId, uint16 _proofType, bytes calldata _adapterParams) external onlyOwner {\n        defaultAdapterParams[_chainId][_proofType] = _adapterParams;\n        emit SetDefaultAdapterParamsForChainId(_chainId, _proofType, _adapterParams);\n    }\n\n    function setRemoteUln(uint16 _remoteChainId, bytes32 _remoteUln) external onlyOwner {\n        require(ulnLookup[_remoteChainId] == bytes32(0), \"LayerZero: remote uln already set\");\n        ulnLookup[_remoteChainId] = _remoteUln;\n        emit SetRemoteUln(_remoteChainId, _remoteUln);\n    }\n\n    function setChainAddressSize(uint16 _chainId, uint _size) external onlyOwner {\n        require(chainAddressSizeMap[_chainId] == 0, \"LayerZero: remote chain address size already set\");\n        chainAddressSizeMap[_chainId] = _size;\n        emit SetChainAddressSize(_chainId, _size);\n    }\n\n    //----------------------------------------------------------------------------------\n    // view functions\n\n    function accruedNativeFee(address _address) external view override returns (uint) {\n        return nativeFees[_address];\n    }\n\n    function getOutboundNonce(uint16 _chainId, bytes calldata _path) external view override returns (uint64) {\n        return nonceContract.outboundNonce(_chainId, _path);\n    }\n\n    function _isContract(address addr) internal view returns (bool) {\n        uint size;\n        assembly {\n            size := extcodesize(addr)\n        }\n        return size != 0;\n    }\n}\n"}}

                    File 5 of 9: OptimizedTransparentUpgradeableProxy
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    /**
                     * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
                     * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
                     * be specified by overriding the virtual {_implementation} function.
                     * 
                     * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
                     * different contract through the {_delegate} function.
                     * 
                     * The success and return data of the delegated call will be returned back to the caller of the proxy.
                     */
                    abstract contract Proxy {
                        /**
                         * @dev Delegates the current call to `implementation`.
                         * 
                         * This function does not return to its internall call site, it will return directly to the external caller.
                         */
                        function _delegate(address implementation) internal {
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                // Copy msg.data. We take full control of memory in this inline assembly
                                // block because it will not return to Solidity code. We overwrite the
                                // Solidity scratch pad at memory position 0.
                                calldatacopy(0, 0, calldatasize())
                                // Call the implementation.
                                // out and outsize are 0 because we don't know the size yet.
                                let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                                // Copy the returned data.
                                returndatacopy(0, 0, returndatasize())
                                switch result
                                // delegatecall returns 0 on error.
                                case 0 { revert(0, returndatasize()) }
                                default { return(0, returndatasize()) }
                            }
                        }
                        /**
                         * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
                         * and {_fallback} should delegate.
                         */
                        function _implementation() internal virtual view returns (address);
                        /**
                         * @dev Delegates the current call to the address returned by `_implementation()`.
                         * 
                         * This function does not return to its internall call site, it will return directly to the external caller.
                         */
                        function _fallback() internal {
                            _beforeFallback();
                            _delegate(_implementation());
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
                         * function in the contract matches the call data.
                         */
                        fallback () payable external {
                            _fallback();
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
                         * is empty.
                         */
                        receive () payable external {
                            _fallback();
                        }
                        /**
                         * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
                         * call, or as part of the Solidity `fallback` or `receive` functions.
                         * 
                         * If overriden should call `super._beforeFallback()`.
                         */
                        function _beforeFallback() internal virtual {
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "./Proxy.sol";
                    import "../utils/Address.sol";
                    /**
                     * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                     * implementation address that can be changed. This address is stored in storage in the location specified by
                     * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
                     * implementation behind the proxy.
                     * 
                     * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see
                     * {TransparentUpgradeableProxy}.
                     */
                    contract UpgradeableProxy is Proxy {
                        /**
                         * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
                         * 
                         * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
                         * function call, and allows initializating the storage of the proxy like a Solidity constructor.
                         */
                        constructor(address _logic, bytes memory _data) payable {
                            assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
                            _setImplementation(_logic);
                            if(_data.length > 0) {
                                // solhint-disable-next-line avoid-low-level-calls
                                (bool success,) = _logic.delegatecall(_data);
                                require(success);
                            }
                        }
                        /**
                         * @dev Emitted when the implementation is upgraded.
                         */
                        event Upgraded(address indexed implementation);
                        /**
                         * @dev Storage slot with the address of the current implementation.
                         * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                        /**
                         * @dev Returns the current implementation address.
                         */
                        function _implementation() internal override view returns (address impl) {
                            bytes32 slot = _IMPLEMENTATION_SLOT;
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                impl := sload(slot)
                            }
                        }
                        /**
                         * @dev Upgrades the proxy to a new implementation.
                         * 
                         * Emits an {Upgraded} event.
                         */
                        function _upgradeTo(address newImplementation) internal {
                            _setImplementation(newImplementation);
                            emit Upgraded(newImplementation);
                        }
                        /**
                         * @dev Stores a new address in the EIP1967 implementation slot.
                         */
                        function _setImplementation(address newImplementation) private {
                            require(Address.isContract(newImplementation), "UpgradeableProxy: new implementation is not a contract");
                            bytes32 slot = _IMPLEMENTATION_SLOT;
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                sstore(slot, newImplementation)
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    /**
                     * @dev Collection of functions related to the address type
                     */
                    library Address {
                        /**
                         * @dev Returns true if `account` is a contract.
                         *
                         * [IMPORTANT]
                         * ====
                         * It is unsafe to assume that an address for which this function returns
                         * false is an externally-owned account (EOA) and not a contract.
                         *
                         * Among others, `isContract` will return false for the following
                         * types of addresses:
                         *
                         *  - an externally-owned account
                         *  - a contract in construction
                         *  - an address where a contract will be created
                         *  - an address where a contract lived, but was destroyed
                         * ====
                         */
                        function isContract(address account) internal view returns (bool) {
                            // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
                            // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
                            // for accounts without code, i.e. `keccak256('')`
                            bytes32 codehash;
                            bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
                            // solhint-disable-next-line no-inline-assembly
                            assembly { codehash := extcodehash(account) }
                            return (codehash != accountHash && codehash != 0x0);
                        }
                        /**
                         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                         * `recipient`, forwarding all available gas and reverting on errors.
                         *
                         * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                         * of certain opcodes, possibly making contracts go over the 2300 gas limit
                         * imposed by `transfer`, making them unable to receive funds via
                         * `transfer`. {sendValue} removes this limitation.
                         *
                         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                         *
                         * IMPORTANT: because control is transferred to `recipient`, care must be
                         * taken to not create reentrancy vulnerabilities. Consider using
                         * {ReentrancyGuard} or the
                         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                         */
                        function sendValue(address payable recipient, uint256 amount) internal {
                            require(address(this).balance >= amount, "Address: insufficient balance");
                            // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
                            (bool success, ) = recipient.call{ value: amount }("");
                            require(success, "Address: unable to send value, recipient may have reverted");
                        }
                        /**
                         * @dev Performs a Solidity function call using a low level `call`. A
                         * plain`call` is an unsafe replacement for a function call: use this
                         * function instead.
                         *
                         * If `target` reverts with a revert reason, it is bubbled up by this
                         * function (like regular Solidity function calls).
                         *
                         * Returns the raw returned data. To convert to the expected return value,
                         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                         *
                         * Requirements:
                         *
                         * - `target` must be a contract.
                         * - calling `target` with `data` must not revert.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                          return functionCall(target, data, "Address: low-level call failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                         * `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
                            return _functionCallWithValue(target, data, 0, errorMessage);
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                         * but also transferring `value` wei to `target`.
                         *
                         * Requirements:
                         *
                         * - the calling contract must have an ETH balance of at least `value`.
                         * - the called Solidity function must be `payable`.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
                            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                         * with `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
                            require(address(this).balance >= value, "Address: insufficient balance for call");
                            return _functionCallWithValue(target, data, value, errorMessage);
                        }
                        function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
                            require(isContract(target), "Address: call to non-contract");
                            // solhint-disable-next-line avoid-low-level-calls
                            (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
                            if (success) {
                                return returndata;
                            } else {
                                // Look for revert reason and bubble it up if present
                                if (returndata.length > 0) {
                                    // The easiest way to bubble the revert reason is using memory via assembly
                                    // solhint-disable-next-line no-inline-assembly
                                    assembly {
                                        let returndata_size := mload(returndata)
                                        revert(add(32, returndata), returndata_size)
                                    }
                                } else {
                                    revert(errorMessage);
                                }
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "../openzeppelin/proxy/UpgradeableProxy.sol";
                    /**
                     * @dev This contract implements a proxy that is upgradeable by an admin.
                     *
                     * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
                     * clashing], which can potentially be used in an attack, this contract uses the
                     * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
                     * things that go hand in hand:
                     *
                     * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
                     * that call matches one of the admin functions exposed by the proxy itself.
                     * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
                     * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
                     * "admin cannot fallback to proxy target".
                     *
                     * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
                     * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
                     * to sudden errors when trying to call a function from the proxy implementation.
                     *
                     * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
                     * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.
                     */
                    contract OptimizedTransparentUpgradeableProxy is UpgradeableProxy {
                        address internal immutable _ADMIN;
                        /**
                         * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
                         * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.
                         */
                        constructor(
                            address initialLogic,
                            address initialAdmin,
                            bytes memory _data
                        ) payable UpgradeableProxy(initialLogic, _data) {
                            assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
                            bytes32 slot = _ADMIN_SLOT;
                            _ADMIN = initialAdmin;
                            // still store it to work with EIP-1967
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                sstore(slot, initialAdmin)
                            }
                        }
                        /**
                         * @dev Storage slot with the admin of the contract.
                         * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
                        /**
                         * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
                         */
                        modifier ifAdmin() {
                            if (msg.sender == _admin()) {
                                _;
                            } else {
                                _fallback();
                            }
                        }
                        /**
                         * @dev Returns the current admin.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
                         */
                        function admin() external ifAdmin returns (address) {
                            return _admin();
                        }
                        /**
                         * @dev Returns the current implementation.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
                         */
                        function implementation() external ifAdmin returns (address) {
                            return _implementation();
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
                         */
                        function upgradeTo(address newImplementation) external ifAdmin {
                            _upgradeTo(newImplementation);
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
                         * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
                         * proxied contract.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
                         */
                        function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
                            _upgradeTo(newImplementation);
                            // solhint-disable-next-line avoid-low-level-calls
                            (bool success, ) = newImplementation.delegatecall(data);
                            require(success);
                        }
                        /**
                         * @dev Returns the current admin.
                         */
                        function _admin() internal view returns (address adm) {
                            return _ADMIN;
                        }
                        /**
                         * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
                         */
                        function _beforeFallback() internal virtual override {
                            require(msg.sender != _admin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
                            super._beforeFallback();
                        }
                    }
                    

                    File 6 of 9: Endpoint
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity 0.7.6;
                    import "./interfaces/ILayerZeroReceiver.sol";
                    import "./interfaces/ILayerZeroEndpoint.sol";
                    import "./interfaces/ILayerZeroMessagingLibrary.sol";
                    import "@openzeppelin/contracts/access/Ownable.sol";
                    contract Endpoint is Ownable, ILayerZeroEndpoint {
                        uint16 public immutable chainId;
                        // installed libraries and reserved versions
                        uint16 public constant BLOCK_VERSION = 65535;
                        uint16 public constant DEFAULT_VERSION = 0;
                        uint16 public latestVersion;
                        mapping(uint16 => ILayerZeroMessagingLibrary) public libraryLookup; // version -> ILayerZeroEndpointLibrary
                        // default send/receive libraries
                        uint16 public defaultSendVersion;
                        uint16 public defaultReceiveVersion;
                        ILayerZeroMessagingLibrary public defaultSendLibrary;
                        address public defaultReceiveLibraryAddress;
                        struct LibraryConfig {
                            uint16 sendVersion;
                            uint16 receiveVersion;
                            address receiveLibraryAddress;
                            ILayerZeroMessagingLibrary sendLibrary;
                        }
                        struct StoredPayload {
                            uint64 payloadLength;
                            address dstAddress;
                            bytes32 payloadHash;
                        }
                        // user app config = [uaAddress]
                        mapping(address => LibraryConfig) public uaConfigLookup;
                        // inboundNonce = [srcChainId][srcAddress].
                        mapping(uint16 => mapping(bytes => uint64)) public inboundNonce;
                        // outboundNonce = [dstChainId][srcAddress].
                        mapping(uint16 => mapping(address => uint64)) public outboundNonce;
                        // storedPayload = [srcChainId][srcAddress]
                        mapping(uint16 => mapping(bytes => StoredPayload)) public storedPayload;
                        // library versioning events
                        event NewLibraryVersionAdded(uint16 version);
                        event DefaultSendVersionSet(uint16 version);
                        event DefaultReceiveVersionSet(uint16 version);
                        event UaSendVersionSet(address ua, uint16 version);
                        event UaReceiveVersionSet(address ua, uint16 version);
                        event UaForceResumeReceive(uint16 chainId, bytes srcAddress);
                        // payload events
                        event PayloadCleared(uint16 srcChainId, bytes srcAddress, uint64 nonce, address dstAddress);
                        event PayloadStored(uint16 srcChainId, bytes srcAddress, address dstAddress, uint64 nonce, bytes payload, bytes reason);
                        constructor(uint16 _chainId) {
                            chainId = _chainId;
                        }
                        //---------------------------------------------------------------------------
                        // send and receive nonreentrant lock
                        uint8 internal constant _NOT_ENTERED = 1;
                        uint8 internal constant _ENTERED = 2;
                        uint8 internal _send_entered_state = 1;
                        uint8 internal _receive_entered_state = 1;
                        modifier sendNonReentrant() {
                            require(_send_entered_state == _NOT_ENTERED, "LayerZero: no send reentrancy");
                            _send_entered_state = _ENTERED;
                            _;
                            _send_entered_state = _NOT_ENTERED;
                        }
                        modifier receiveNonReentrant() {
                            require(_receive_entered_state == _NOT_ENTERED, "LayerZero: no receive reentrancy");
                            _receive_entered_state = _ENTERED;
                            _;
                            _receive_entered_state = _NOT_ENTERED;
                        }
                        // BLOCK_VERSION is also a valid version
                        modifier validVersion(uint16 _version) {
                            require(_version <= latestVersion || _version == BLOCK_VERSION, "LayerZero: invalid messaging library version");
                            _;
                        }
                        //---------------------------------------------------------------------------
                        // User Application Calls - Endpoint Interface
                        function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable override sendNonReentrant {
                            LibraryConfig storage uaConfig = uaConfigLookup[msg.sender];
                            uint64 nonce = ++outboundNonce[_dstChainId][msg.sender];
                            _getSendLibrary(uaConfig).send{value: msg.value}(msg.sender, nonce, _dstChainId, _destination, _payload, _refundAddress, _zroPaymentAddress, _adapterParams);
                        }
                        //---------------------------------------------------------------------------
                        // authenticated Library (msg.sender) Calls to pass through Endpoint to UA (dstAddress)
                        function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external override receiveNonReentrant {
                            // assert and increment the nonce. no message shuffling
                            require(_nonce == ++inboundNonce[_srcChainId][_srcAddress], "LayerZero: wrong nonce");
                            LibraryConfig storage uaConfig = uaConfigLookup[_dstAddress];
                            // authentication to prevent cross-version message validation
                            // protects against a malicious library from passing arbitrary data
                            if (uaConfig.receiveVersion == DEFAULT_VERSION) {
                                require(defaultReceiveLibraryAddress == msg.sender, "LayerZero: invalid default library");
                            } else {
                                require(uaConfig.receiveLibraryAddress == msg.sender, "LayerZero: invalid library");
                            }
                            // block if any message blocking
                            StoredPayload storage sp = storedPayload[_srcChainId][_srcAddress];
                            require(sp.payloadHash == bytes32(0), "LayerZero: in message blocking");
                            try ILayerZeroReceiver(_dstAddress).lzReceive{gas: _gasLimit}(_srcChainId, _srcAddress, _nonce, _payload) {
                                // success, do nothing, end of the message delivery
                            } catch (bytes memory reason) {
                                // revert nonce if any uncaught errors/exceptions if the ua chooses the blocking mode
                                storedPayload[_srcChainId][_srcAddress] = StoredPayload(uint64(_payload.length), _dstAddress, keccak256(_payload));
                                emit PayloadStored(_srcChainId, _srcAddress, _dstAddress, _nonce, _payload, reason);
                            }
                        }
                        function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external override receiveNonReentrant {
                            StoredPayload storage sp = storedPayload[_srcChainId][_srcAddress];
                            require(sp.payloadHash != bytes32(0), "LayerZero: no stored payload");
                            require(_payload.length == sp.payloadLength && keccak256(_payload) == sp.payloadHash, "LayerZero: invalid payload");
                            address dstAddress = sp.dstAddress;
                            // empty the storedPayload
                            sp.payloadLength = 0;
                            sp.dstAddress = address(0);
                            sp.payloadHash = bytes32(0);
                            uint64 nonce = inboundNonce[_srcChainId][_srcAddress];
                            ILayerZeroReceiver(dstAddress).lzReceive(_srcChainId, _srcAddress, nonce, _payload);
                            emit PayloadCleared(_srcChainId, _srcAddress, nonce, dstAddress);
                        }
                        //---------------------------------------------------------------------------
                        // Owner Calls, only new library version upgrade (3 steps)
                        // note libraryLookup[0] = 0x0, no library implementation
                        // LIBRARY UPGRADE step 1: set _newLayerZeroLibraryAddress be the new version
                        function newVersion(address _newLayerZeroLibraryAddress) external onlyOwner {
                            require(_newLayerZeroLibraryAddress != address(0x0), "LayerZero: new version cannot be zero address");
                            require(latestVersion < 65535, "LayerZero: can not add new messaging library");
                            latestVersion++;
                            libraryLookup[latestVersion] = ILayerZeroMessagingLibrary(_newLayerZeroLibraryAddress);
                            emit NewLibraryVersionAdded(latestVersion);
                        }
                        // LIBRARY UPGRADE step 2: stop sending messages from the old version
                        function setDefaultSendVersion(uint16 _newDefaultSendVersion) external onlyOwner validVersion(_newDefaultSendVersion) {
                            require(_newDefaultSendVersion != DEFAULT_VERSION, "LayerZero: default send version must > 0");
                            defaultSendVersion = _newDefaultSendVersion;
                            defaultSendLibrary = libraryLookup[defaultSendVersion];
                            emit DefaultSendVersionSet(_newDefaultSendVersion);
                        }
                        // LIBRARY UPGRADE step 3: stop receiving messages from the old version
                        function setDefaultReceiveVersion(uint16 _newDefaultReceiveVersion) external onlyOwner validVersion(_newDefaultReceiveVersion) {
                            require(_newDefaultReceiveVersion != DEFAULT_VERSION, "LayerZero: default receive version must > 0");
                            defaultReceiveVersion = _newDefaultReceiveVersion;
                            defaultReceiveLibraryAddress = address(libraryLookup[defaultReceiveVersion]);
                            emit DefaultReceiveVersionSet(_newDefaultReceiveVersion);
                        }
                        //---------------------------------------------------------------------------
                        // User Application Calls - UA set/get Interface
                        function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external override validVersion(_version) {
                            if (_version == DEFAULT_VERSION) {
                                require(defaultSendVersion == defaultReceiveVersion, "LayerZero: can not set Config during DEFAULT migration");
                                _version = defaultSendVersion;
                            }
                            require(_version != BLOCK_VERSION, "LayerZero: can not set config for BLOCK_VERSION");
                            libraryLookup[_version].setConfig(_chainId, msg.sender, _configType, _config);
                        }
                        // Migration step 1: set the send version
                        // Define what library the UA points too
                        function setSendVersion(uint16 _newVersion) external override validVersion(_newVersion) {
                            // write into config
                            LibraryConfig storage uaConfig = uaConfigLookup[msg.sender];
                            uaConfig.sendVersion = _newVersion;
                            // the libraryLookup[BLOCK_VERSION || DEFAULT_VERSION] = 0x0
                            uaConfig.sendLibrary = libraryLookup[_newVersion];
                            emit UaSendVersionSet(msg.sender, _newVersion);
                        }
                        // Migration step 2: set the receive version
                        // after all messages sent from the old version are received
                        // the UA can now safely switch to the new receive version
                        // it is the UA's responsibility make sure all messages from the old version are processed
                        function setReceiveVersion(uint16 _newVersion) external override validVersion(_newVersion) {
                            // write into config
                            LibraryConfig storage uaConfig = uaConfigLookup[msg.sender];
                            uaConfig.receiveVersion = _newVersion;
                            // the libraryLookup[BLOCK_VERSION || DEFAULT_VERSION] = 0x0
                            uaConfig.receiveLibraryAddress = address(libraryLookup[_newVersion]);
                            emit UaReceiveVersionSet(msg.sender, _newVersion);
                        }
                        function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external override {
                            StoredPayload storage sp = storedPayload[_srcChainId][_srcAddress];
                            // revert if no messages are cached. safeguard malicious UA behaviour
                            require(sp.payloadHash != bytes32(0), "LayerZero: no stored payload");
                            require(sp.dstAddress == msg.sender, "LayerZero: invalid caller");
                            // empty the storedPayload
                            sp.payloadLength = 0;
                            sp.dstAddress = address(0);
                            sp.payloadHash = bytes32(0);
                            // emit the event with the new nonce
                            emit UaForceResumeReceive(_srcChainId, _srcAddress);
                        }
                        //---------------------------------------------------------------------------
                        // view helper function
                        function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParams) external view override returns (uint nativeFee, uint zroFee) {
                            LibraryConfig storage uaConfig = uaConfigLookup[_userApplication];
                            ILayerZeroMessagingLibrary lib = uaConfig.sendVersion == DEFAULT_VERSION ? defaultSendLibrary : uaConfig.sendLibrary;
                            return lib.estimateFees(_dstChainId, _userApplication, _payload, _payInZRO, _adapterParams);
                        }
                        function _getSendLibrary(LibraryConfig storage uaConfig) internal view returns (ILayerZeroMessagingLibrary) {
                            if (uaConfig.sendVersion == DEFAULT_VERSION) {
                                // check if the in send-blocking upgrade
                                require(defaultSendVersion != BLOCK_VERSION, "LayerZero: default in BLOCK_VERSION");
                                return defaultSendLibrary;
                            } else {
                                // check if the in send-blocking upgrade
                                require(uaConfig.sendVersion != BLOCK_VERSION, "LayerZero: in BLOCK_VERSION");
                                return uaConfig.sendLibrary;
                            }
                        }
                        function getSendLibraryAddress(address _userApplication) external view override returns (address sendLibraryAddress) {
                            LibraryConfig storage uaConfig = uaConfigLookup[_userApplication];
                            uint16 sendVersion = uaConfig.sendVersion;
                            require(sendVersion != BLOCK_VERSION, "LayerZero: send version is BLOCK_VERSION");
                            if (sendVersion == DEFAULT_VERSION) {
                                require(defaultSendVersion != BLOCK_VERSION, "LayerZero: send version (default) is BLOCK_VERSION");
                                sendLibraryAddress = address(defaultSendLibrary);
                            } else {
                                sendLibraryAddress = address(uaConfig.sendLibrary);
                            }
                        }
                        function getReceiveLibraryAddress(address _userApplication) external view override returns (address receiveLibraryAddress) {
                            LibraryConfig storage uaConfig = uaConfigLookup[_userApplication];
                            uint16 receiveVersion = uaConfig.receiveVersion;
                            require(receiveVersion != BLOCK_VERSION, "LayerZero: receive version is BLOCK_VERSION");
                            if (receiveVersion == DEFAULT_VERSION) {
                                require(defaultReceiveVersion != BLOCK_VERSION, "LayerZero: receive version (default) is BLOCK_VERSION");
                                receiveLibraryAddress = defaultReceiveLibraryAddress;
                            } else {
                                receiveLibraryAddress = uaConfig.receiveLibraryAddress;
                            }
                        }
                        function isSendingPayload() external view override returns (bool) {
                            return _send_entered_state == _ENTERED;
                        }
                        function isReceivingPayload() external view override returns (bool) {
                            return _receive_entered_state == _ENTERED;
                        }
                        function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view override returns (uint64) {
                            return inboundNonce[_srcChainId][_srcAddress];
                        }
                        function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view override returns (uint64) {
                            return outboundNonce[_dstChainId][_srcAddress];
                        }
                        function getChainId() external view override returns (uint16) {
                            return chainId;
                        }
                        function getSendVersion(address _userApplication) external view override returns (uint16) {
                            LibraryConfig storage uaConfig = uaConfigLookup[_userApplication];
                            return uaConfig.sendVersion == DEFAULT_VERSION ? defaultSendVersion : uaConfig.sendVersion;
                        }
                        function getReceiveVersion(address _userApplication) external view override returns (uint16) {
                            LibraryConfig storage uaConfig = uaConfigLookup[_userApplication];
                            return uaConfig.receiveVersion == DEFAULT_VERSION ? defaultReceiveVersion : uaConfig.receiveVersion;
                        }
                        function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view override validVersion(_version) returns (bytes memory) {
                            if (_version == DEFAULT_VERSION) {
                                require(defaultSendVersion == defaultReceiveVersion, "LayerZero: no DEFAULT config while migration");
                                _version = defaultSendVersion;
                            }
                            require(_version != BLOCK_VERSION, "LayerZero: can not get config for BLOCK_VERSION");
                            return libraryLookup[_version].getConfig(_chainId, _userApplication, _configType);
                        }
                        function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view override returns (bool) {
                            StoredPayload storage sp = storedPayload[_srcChainId][_srcAddress];
                            return sp.payloadHash != bytes32(0);
                        }
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    interface ILayerZeroReceiver {
                        // @notice LayerZero endpoint will invoke this function to deliver the message on the destination
                        // @param _srcChainId - the source endpoint identifier
                        // @param _srcAddress - the source sending contract address from the source chain
                        // @param _nonce - the ordered message nonce
                        // @param _payload - the signed payload is the UA bytes has encoded to be sent
                        function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    import "./ILayerZeroUserApplicationConfig.sol";
                    interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
                        // @notice send a LayerZero message to the specified address at a LayerZero endpoint.
                        // @param _dstChainId - the destination chain identifier
                        // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
                        // @param _payload - a custom bytes payload to send to the destination contract
                        // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
                        // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
                        // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
                        function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        // @notice used by the messaging library to publish verified payload
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source contract (as bytes) at the source chain
                        // @param _dstAddress - the address on destination chain
                        // @param _nonce - the unbound message ordering nonce
                        // @param _gasLimit - the gas limit for external contract execution
                        // @param _payload - verified payload to send to the destination contract
                        function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;
                        // @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);
                        // @notice get the outboundNonce from this source chain which, consequently, is always an EVM
                        // @param _srcAddress - the source chain contract address
                        function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);
                        // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery
                        // @param _dstChainId - the destination chain identifier
                        // @param _userApplication - the user app address on this EVM chain
                        // @param _payload - the custom message to send over LayerZero
                        // @param _payInZRO - if false, user app pays the protocol fee in native token
                        // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain
                        function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);
                        // @notice get this Endpoint's immutable source identifier
                        function getChainId() external view returns (uint16);
                        // @notice the interface to retry failed message on this Endpoint destination
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        // @param _payload - the payload to be retried
                        function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;
                        // @notice query if any STORED payload (message blocking) at the endpoint.
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);
                        // @notice query if the _libraryAddress is valid for sending msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getSendLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the _libraryAddress is valid for receiving msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getReceiveLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the non-reentrancy guard for send() is on
                        // @return true if the guard is on. false otherwise
                        function isSendingPayload() external view returns (bool);
                        // @notice query if the non-reentrancy guard for receive() is on
                        // @return true if the guard is on. false otherwise
                        function isReceivingPayload() external view returns (bool);
                        // @notice get the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _userApplication - the contract address of the user application
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
                        // @notice get the send() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getSendVersion(address _userApplication) external view returns (uint16);
                        // @notice get the lzReceive() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getReceiveVersion(address _userApplication) external view returns (uint16);
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.7.0;
                    import "./ILayerZeroUserApplicationConfig.sol";
                    interface ILayerZeroMessagingLibrary {
                        // send(), messages will be inflight.
                        function send(address _userApplication, uint64 _lastNonce, uint16 _chainId, bytes calldata _destination, bytes calldata _payload, address payable refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        // estimate native fee at the send side
                        function estimateFees(uint16 _chainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);
                        //---------------------------------------------------------------------------
                        // setConfig / getConfig are User Application (UA) functions to specify Oracle, Relayer, blockConfirmations, libraryVersion
                        function setConfig(uint16 _chainId, address _userApplication, uint _configType, bytes calldata _config) external;
                        function getConfig(uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "../utils/Context.sol";
                    /**
                     * @dev Contract module which provides a basic access control mechanism, where
                     * there is an account (an owner) that can be granted exclusive access to
                     * specific functions.
                     *
                     * By default, the owner account will be the one that deploys the contract. This
                     * can later be changed with {transferOwnership}.
                     *
                     * This module is used through inheritance. It will make available the modifier
                     * `onlyOwner`, which can be applied to your functions to restrict their use to
                     * the owner.
                     */
                    abstract contract Ownable is Context {
                        address private _owner;
                        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
                        /**
                         * @dev Initializes the contract setting the deployer as the initial owner.
                         */
                        constructor () {
                            address msgSender = _msgSender();
                            _owner = msgSender;
                            emit OwnershipTransferred(address(0), msgSender);
                        }
                        /**
                         * @dev Returns the address of the current owner.
                         */
                        function owner() public view virtual returns (address) {
                            return _owner;
                        }
                        /**
                         * @dev Throws if called by any account other than the owner.
                         */
                        modifier onlyOwner() {
                            require(owner() == _msgSender(), "Ownable: caller is not the owner");
                            _;
                        }
                        /**
                         * @dev Leaves the contract without owner. It will not be possible to call
                         * `onlyOwner` functions anymore. Can only be called by the current owner.
                         *
                         * NOTE: Renouncing ownership will leave the contract without an owner,
                         * thereby removing any functionality that is only available to the owner.
                         */
                        function renounceOwnership() public virtual onlyOwner {
                            emit OwnershipTransferred(_owner, address(0));
                            _owner = address(0);
                        }
                        /**
                         * @dev Transfers ownership of the contract to a new account (`newOwner`).
                         * Can only be called by the current owner.
                         */
                        function transferOwnership(address newOwner) public virtual onlyOwner {
                            require(newOwner != address(0), "Ownable: new owner is the zero address");
                            emit OwnershipTransferred(_owner, newOwner);
                            _owner = newOwner;
                        }
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    interface ILayerZeroUserApplicationConfig {
                        // @notice set the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        // @param _config - configuration in the bytes. can encode arbitrary content.
                        function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;
                        // @notice set the send() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setSendVersion(uint16 _version) external;
                        // @notice set the lzReceive() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setReceiveVersion(uint16 _version) external;
                        // @notice Only when the UA needs to resume the message flow in blocking mode and clear the stored payload
                        // @param _srcChainId - the chainId of the source chain
                        // @param _srcAddress - the contract address of the source contract at the source chain
                        function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.6.0 <0.8.0;
                    /*
                     * @dev Provides information about the current execution context, including the
                     * sender of the transaction and its data. While these are generally available
                     * via msg.sender and msg.data, they should not be accessed in such a direct
                     * manner, since when dealing with GSN meta-transactions the account sending and
                     * paying for execution may not be the actual sender (as far as an application
                     * is concerned).
                     *
                     * This contract is only required for intermediate, library-like contracts.
                     */
                    abstract contract Context {
                        function _msgSender() internal view virtual returns (address payable) {
                            return msg.sender;
                        }
                        function _msgData() internal view virtual returns (bytes memory) {
                            this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
                            return msg.data;
                        }
                    }
                    

                    File 7 of 9: NonceContract
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity 0.7.6;
                    import "./interfaces/ILayerZeroEndpoint.sol";
                    contract NonceContract {
                        ILayerZeroEndpoint public immutable endpoint;
                        // outboundNonce = [dstChainId][remoteAddress + localAddress]
                        mapping(uint16 => mapping(bytes => uint64)) public outboundNonce;
                        constructor(address _endpoint) {
                            endpoint = ILayerZeroEndpoint(_endpoint);
                        }
                        function increment(uint16 _chainId, address _ua, bytes calldata _path) external returns (uint64) {
                            require(endpoint.getSendLibraryAddress(_ua) == msg.sender, "NonceContract: msg.sender is not valid sendlibrary");
                            return ++outboundNonce[_chainId][_path];
                        }
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    import "./ILayerZeroUserApplicationConfig.sol";
                    interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
                        // @notice send a LayerZero message to the specified address at a LayerZero endpoint.
                        // @param _dstChainId - the destination chain identifier
                        // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
                        // @param _payload - a custom bytes payload to send to the destination contract
                        // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
                        // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
                        // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
                        function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;
                        // @notice used by the messaging library to publish verified payload
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source contract (as bytes) at the source chain
                        // @param _dstAddress - the address on destination chain
                        // @param _nonce - the unbound message ordering nonce
                        // @param _gasLimit - the gas limit for external contract execution
                        // @param _payload - verified payload to send to the destination contract
                        function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;
                        // @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);
                        // @notice get the outboundNonce from this source chain which, consequently, is always an EVM
                        // @param _srcAddress - the source chain contract address
                        function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);
                        // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery
                        // @param _dstChainId - the destination chain identifier
                        // @param _userApplication - the user app address on this EVM chain
                        // @param _payload - the custom message to send over LayerZero
                        // @param _payInZRO - if false, user app pays the protocol fee in native token
                        // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain
                        function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);
                        // @notice get this Endpoint's immutable source identifier
                        function getChainId() external view returns (uint16);
                        // @notice the interface to retry failed message on this Endpoint destination
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        // @param _payload - the payload to be retried
                        function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;
                        // @notice query if any STORED payload (message blocking) at the endpoint.
                        // @param _srcChainId - the source chain identifier
                        // @param _srcAddress - the source chain contract address
                        function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);
                        // @notice query if the _libraryAddress is valid for sending msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getSendLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the _libraryAddress is valid for receiving msgs.
                        // @param _userApplication - the user app address on this EVM chain
                        function getReceiveLibraryAddress(address _userApplication) external view returns (address);
                        // @notice query if the non-reentrancy guard for send() is on
                        // @return true if the guard is on. false otherwise
                        function isSendingPayload() external view returns (bool);
                        // @notice query if the non-reentrancy guard for receive() is on
                        // @return true if the guard is on. false otherwise
                        function isReceivingPayload() external view returns (bool);
                        // @notice get the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _userApplication - the contract address of the user application
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);
                        // @notice get the send() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getSendVersion(address _userApplication) external view returns (uint16);
                        // @notice get the lzReceive() LayerZero messaging library version
                        // @param _userApplication - the contract address of the user application
                        function getReceiveVersion(address _userApplication) external view returns (uint16);
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    interface ILayerZeroUserApplicationConfig {
                        // @notice set the configuration of the LayerZero messaging library of the specified version
                        // @param _version - messaging library version
                        // @param _chainId - the chainId for the pending config change
                        // @param _configType - type of configuration. every messaging library has its own convention.
                        // @param _config - configuration in the bytes. can encode arbitrary content.
                        function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;
                        // @notice set the send() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setSendVersion(uint16 _version) external;
                        // @notice set the lzReceive() LayerZero messaging library version to _version
                        // @param _version - new messaging library version
                        function setReceiveVersion(uint16 _version) external;
                        // @notice Only when the UA needs to resume the message flow in blocking mode and clear the stored payload
                        // @param _srcChainId - the chainId of the source chain
                        // @param _srcAddress - the contract address of the source contract at the source chain
                        function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;
                    }
                    

                    File 8 of 9: OptimizedTransparentUpgradeableProxy
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (interfaces/draft-IERC1822.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                     * proxy whose upgrades are fully controlled by the current implementation.
                     */
                    interface IERC1822Proxiable {
                        /**
                         * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                         * address.
                         *
                         * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                         * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                         * function revert if invoked through a proxy.
                         */
                        function proxiableUUID() external view returns (bytes32);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
                    pragma solidity ^0.8.0;
                    import "../Proxy.sol";
                    import "./ERC1967Upgrade.sol";
                    /**
                     * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                     * implementation address that can be changed. This address is stored in storage in the location specified by
                     * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
                     * implementation behind the proxy.
                     */
                    contract ERC1967Proxy is Proxy, ERC1967Upgrade {
                        /**
                         * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
                         *
                         * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
                         * function call, and allows initializating the storage of the proxy like a Solidity constructor.
                         */
                        constructor(address _logic, bytes memory _data) payable {
                            assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
                            _upgradeToAndCall(_logic, _data, false);
                        }
                        /**
                         * @dev Returns the current implementation address.
                         */
                        function _implementation() internal view virtual override returns (address impl) {
                            return ERC1967Upgrade._getImplementation();
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (proxy/ERC1967/ERC1967Upgrade.sol)
                    pragma solidity ^0.8.2;
                    import "../beacon/IBeacon.sol";
                    import "../../interfaces/draft-IERC1822.sol";
                    import "../../utils/Address.sol";
                    import "../../utils/StorageSlot.sol";
                    /**
                     * @dev This abstract contract provides getters and event emitting update functions for
                     * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
                     *
                     * _Available since v4.1._
                     *
                     * @custom:oz-upgrades-unsafe-allow delegatecall
                     */
                    abstract contract ERC1967Upgrade {
                        // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
                        bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
                        /**
                         * @dev Storage slot with the address of the current implementation.
                         * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                        /**
                         * @dev Emitted when the implementation is upgraded.
                         */
                        event Upgraded(address indexed implementation);
                        /**
                         * @dev Returns the current implementation address.
                         */
                        function _getImplementation() internal view returns (address) {
                            return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                        }
                        /**
                         * @dev Stores a new address in the EIP1967 implementation slot.
                         */
                        function _setImplementation(address newImplementation) private {
                            require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                            StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
                        }
                        /**
                         * @dev Perform implementation upgrade
                         *
                         * Emits an {Upgraded} event.
                         */
                        function _upgradeTo(address newImplementation) internal {
                            _setImplementation(newImplementation);
                            emit Upgraded(newImplementation);
                        }
                        /**
                         * @dev Perform implementation upgrade with additional setup call.
                         *
                         * Emits an {Upgraded} event.
                         */
                        function _upgradeToAndCall(
                            address newImplementation,
                            bytes memory data,
                            bool forceCall
                        ) internal {
                            _upgradeTo(newImplementation);
                            if (data.length > 0 || forceCall) {
                                Address.functionDelegateCall(newImplementation, data);
                            }
                        }
                        /**
                         * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
                         *
                         * Emits an {Upgraded} event.
                         */
                        function _upgradeToAndCallUUPS(
                            address newImplementation,
                            bytes memory data,
                            bool forceCall
                        ) internal {
                            // Upgrades from old implementations will perform a rollback test. This test requires the new
                            // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                            // this special case will break upgrade paths from old UUPS implementation to new ones.
                            if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                _setImplementation(newImplementation);
                            } else {
                                try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                    require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                } catch {
                                    revert("ERC1967Upgrade: new implementation is not UUPS");
                                }
                                _upgradeToAndCall(newImplementation, data, forceCall);
                            }
                        }
                        /**
                         * @dev Storage slot with the admin of the contract.
                         * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
                         * validated in the constructor.
                         */
                        bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
                        /**
                         * @dev Emitted when the admin account has changed.
                         */
                        event AdminChanged(address previousAdmin, address newAdmin);
                        /**
                         * @dev Returns the current admin.
                         */
                        function _getAdmin() internal view virtual returns (address) {
                            return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
                        }
                        /**
                         * @dev Stores a new address in the EIP1967 admin slot.
                         */
                        function _setAdmin(address newAdmin) private {
                            require(newAdmin != address(0), "ERC1967: new admin is the zero address");
                            StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
                        }
                        /**
                         * @dev Changes the admin of the proxy.
                         *
                         * Emits an {AdminChanged} event.
                         */
                        function _changeAdmin(address newAdmin) internal {
                            emit AdminChanged(_getAdmin(), newAdmin);
                            _setAdmin(newAdmin);
                        }
                        /**
                         * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
                         * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
                         */
                        bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
                        /**
                         * @dev Emitted when the beacon is upgraded.
                         */
                        event BeaconUpgraded(address indexed beacon);
                        /**
                         * @dev Returns the current beacon.
                         */
                        function _getBeacon() internal view returns (address) {
                            return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
                        }
                        /**
                         * @dev Stores a new beacon in the EIP1967 beacon slot.
                         */
                        function _setBeacon(address newBeacon) private {
                            require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
                            require(Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract");
                            StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
                        }
                        /**
                         * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
                         * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
                         *
                         * Emits a {BeaconUpgraded} event.
                         */
                        function _upgradeBeaconToAndCall(
                            address newBeacon,
                            bytes memory data,
                            bool forceCall
                        ) internal {
                            _setBeacon(newBeacon);
                            emit BeaconUpgraded(newBeacon);
                            if (data.length > 0 || forceCall) {
                                Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (proxy/Proxy.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
                     * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
                     * be specified by overriding the virtual {_implementation} function.
                     *
                     * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
                     * different contract through the {_delegate} function.
                     *
                     * The success and return data of the delegated call will be returned back to the caller of the proxy.
                     */
                    abstract contract Proxy {
                        /**
                         * @dev Delegates the current call to `implementation`.
                         *
                         * This function does not return to its internal call site, it will return directly to the external caller.
                         */
                        function _delegate(address implementation) internal virtual {
                            assembly {
                                // Copy msg.data. We take full control of memory in this inline assembly
                                // block because it will not return to Solidity code. We overwrite the
                                // Solidity scratch pad at memory position 0.
                                calldatacopy(0, 0, calldatasize())
                                // Call the implementation.
                                // out and outsize are 0 because we don't know the size yet.
                                let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                                // Copy the returned data.
                                returndatacopy(0, 0, returndatasize())
                                switch result
                                // delegatecall returns 0 on error.
                                case 0 {
                                    revert(0, returndatasize())
                                }
                                default {
                                    return(0, returndatasize())
                                }
                            }
                        }
                        /**
                         * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
                         * and {_fallback} should delegate.
                         */
                        function _implementation() internal view virtual returns (address);
                        /**
                         * @dev Delegates the current call to the address returned by `_implementation()`.
                         *
                         * This function does not return to its internall call site, it will return directly to the external caller.
                         */
                        function _fallback() internal virtual {
                            _beforeFallback();
                            _delegate(_implementation());
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
                         * function in the contract matches the call data.
                         */
                        fallback() external payable virtual {
                            _fallback();
                        }
                        /**
                         * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
                         * is empty.
                         */
                        receive() external payable virtual {
                            _fallback();
                        }
                        /**
                         * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
                         * call, or as part of the Solidity `fallback` or `receive` functions.
                         *
                         * If overriden should call `super._beforeFallback()`.
                         */
                        function _beforeFallback() internal virtual {}
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev This is the interface that {BeaconProxy} expects of its beacon.
                     */
                    interface IBeacon {
                        /**
                         * @dev Must return an address that can be used as a delegate call target.
                         *
                         * {BeaconProxy} will check that this address is a contract.
                         */
                        function implementation() external view returns (address);
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts (last updated v4.5.0-rc.0) (utils/Address.sol)
                    pragma solidity ^0.8.1;
                    /**
                     * @dev Collection of functions related to the address type
                     */
                    library Address {
                        /**
                         * @dev Returns true if `account` is a contract.
                         *
                         * [IMPORTANT]
                         * ====
                         * It is unsafe to assume that an address for which this function returns
                         * false is an externally-owned account (EOA) and not a contract.
                         *
                         * Among others, `isContract` will return false for the following
                         * types of addresses:
                         *
                         *  - an externally-owned account
                         *  - a contract in construction
                         *  - an address where a contract will be created
                         *  - an address where a contract lived, but was destroyed
                         * ====
                         *
                         * [IMPORTANT]
                         * ====
                         * You shouldn't rely on `isContract` to protect against flash loan attacks!
                         *
                         * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
                         * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
                         * constructor.
                         * ====
                         */
                        function isContract(address account) internal view returns (bool) {
                            // This method relies on extcodesize/address.code.length, which returns 0
                            // for contracts in construction, since the code is only stored at the end
                            // of the constructor execution.
                            return account.code.length > 0;
                        }
                        /**
                         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                         * `recipient`, forwarding all available gas and reverting on errors.
                         *
                         * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                         * of certain opcodes, possibly making contracts go over the 2300 gas limit
                         * imposed by `transfer`, making them unable to receive funds via
                         * `transfer`. {sendValue} removes this limitation.
                         *
                         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                         *
                         * IMPORTANT: because control is transferred to `recipient`, care must be
                         * taken to not create reentrancy vulnerabilities. Consider using
                         * {ReentrancyGuard} or the
                         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                         */
                        function sendValue(address payable recipient, uint256 amount) internal {
                            require(address(this).balance >= amount, "Address: insufficient balance");
                            (bool success, ) = recipient.call{value: amount}("");
                            require(success, "Address: unable to send value, recipient may have reverted");
                        }
                        /**
                         * @dev Performs a Solidity function call using a low level `call`. A
                         * plain `call` is an unsafe replacement for a function call: use this
                         * function instead.
                         *
                         * If `target` reverts with a revert reason, it is bubbled up by this
                         * function (like regular Solidity function calls).
                         *
                         * Returns the raw returned data. To convert to the expected return value,
                         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                         *
                         * Requirements:
                         *
                         * - `target` must be a contract.
                         * - calling `target` with `data` must not revert.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                            return functionCall(target, data, "Address: low-level call failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                         * `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCall(
                            address target,
                            bytes memory data,
                            string memory errorMessage
                        ) internal returns (bytes memory) {
                            return functionCallWithValue(target, data, 0, errorMessage);
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                         * but also transferring `value` wei to `target`.
                         *
                         * Requirements:
                         *
                         * - the calling contract must have an ETH balance of at least `value`.
                         * - the called Solidity function must be `payable`.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(
                            address target,
                            bytes memory data,
                            uint256 value
                        ) internal returns (bytes memory) {
                            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                         * with `errorMessage` as a fallback revert reason when `target` reverts.
                         *
                         * _Available since v3.1._
                         */
                        function functionCallWithValue(
                            address target,
                            bytes memory data,
                            uint256 value,
                            string memory errorMessage
                        ) internal returns (bytes memory) {
                            require(address(this).balance >= value, "Address: insufficient balance for call");
                            require(isContract(target), "Address: call to non-contract");
                            (bool success, bytes memory returndata) = target.call{value: value}(data);
                            return verifyCallResult(success, returndata, errorMessage);
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                         * but performing a static call.
                         *
                         * _Available since v3.3._
                         */
                        function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                            return functionStaticCall(target, data, "Address: low-level static call failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                         * but performing a static call.
                         *
                         * _Available since v3.3._
                         */
                        function functionStaticCall(
                            address target,
                            bytes memory data,
                            string memory errorMessage
                        ) internal view returns (bytes memory) {
                            require(isContract(target), "Address: static call to non-contract");
                            (bool success, bytes memory returndata) = target.staticcall(data);
                            return verifyCallResult(success, returndata, errorMessage);
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                         * but performing a delegate call.
                         *
                         * _Available since v3.4._
                         */
                        function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
                            return functionDelegateCall(target, data, "Address: low-level delegate call failed");
                        }
                        /**
                         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                         * but performing a delegate call.
                         *
                         * _Available since v3.4._
                         */
                        function functionDelegateCall(
                            address target,
                            bytes memory data,
                            string memory errorMessage
                        ) internal returns (bytes memory) {
                            require(isContract(target), "Address: delegate call to non-contract");
                            (bool success, bytes memory returndata) = target.delegatecall(data);
                            return verifyCallResult(success, returndata, errorMessage);
                        }
                        /**
                         * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
                         * revert reason using the provided one.
                         *
                         * _Available since v4.3._
                         */
                        function verifyCallResult(
                            bool success,
                            bytes memory returndata,
                            string memory errorMessage
                        ) internal pure returns (bytes memory) {
                            if (success) {
                                return returndata;
                            } else {
                                // Look for revert reason and bubble it up if present
                                if (returndata.length > 0) {
                                    // The easiest way to bubble the revert reason is using memory via assembly
                                    assembly {
                                        let returndata_size := mload(returndata)
                                        revert(add(32, returndata), returndata_size)
                                    }
                                } else {
                                    revert(errorMessage);
                                }
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)
                    pragma solidity ^0.8.0;
                    /**
                     * @dev Library for reading and writing primitive types to specific storage slots.
                     *
                     * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
                     * This library helps with reading and writing to such slots without the need for inline assembly.
                     *
                     * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
                     *
                     * Example usage to set ERC1967 implementation slot:
                     * ```
                     * contract ERC1967 {
                     *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                     *
                     *     function _getImplementation() internal view returns (address) {
                     *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                     *     }
                     *
                     *     function _setImplementation(address newImplementation) internal {
                     *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                     *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
                     *     }
                     * }
                     * ```
                     *
                     * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
                     */
                    library StorageSlot {
                        struct AddressSlot {
                            address value;
                        }
                        struct BooleanSlot {
                            bool value;
                        }
                        struct Bytes32Slot {
                            bytes32 value;
                        }
                        struct Uint256Slot {
                            uint256 value;
                        }
                        /**
                         * @dev Returns an `AddressSlot` with member `value` located at `slot`.
                         */
                        function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
                            assembly {
                                r.slot := slot
                            }
                        }
                        /**
                         * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                         */
                        function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                            assembly {
                                r.slot := slot
                            }
                        }
                        /**
                         * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                         */
                        function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                            assembly {
                                r.slot := slot
                            }
                        }
                        /**
                         * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                         */
                        function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                            assembly {
                                r.slot := slot
                            }
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    // OpenZeppelin Contracts v4.4.1 (proxy/transparent/TransparentUpgradeableProxy.sol)
                    pragma solidity ^0.8.0;
                    import "../openzeppelin/proxy/ERC1967/ERC1967Proxy.sol";
                    /**
                     * @dev This contract implements a proxy that is upgradeable by an admin.
                     *
                     * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
                     * clashing], which can potentially be used in an attack, this contract uses the
                     * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
                     * things that go hand in hand:
                     *
                     * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
                     * that call matches one of the admin functions exposed by the proxy itself.
                     * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
                     * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
                     * "admin cannot fallback to proxy target".
                     *
                     * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
                     * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
                     * to sudden errors when trying to call a function from the proxy implementation.
                     *
                     * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
                     * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
                     */
                    contract OptimizedTransparentUpgradeableProxy is ERC1967Proxy {
                        address internal immutable _ADMIN;
                        /**
                         * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
                         * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
                         */
                        constructor(
                            address _logic,
                            address admin_,
                            bytes memory _data
                        ) payable ERC1967Proxy(_logic, _data) {
                            assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
                            _ADMIN = admin_;
                            // still store it to work with EIP-1967
                            bytes32 slot = _ADMIN_SLOT;
                            // solhint-disable-next-line no-inline-assembly
                            assembly {
                                sstore(slot, admin_)
                            }
                            emit AdminChanged(address(0), admin_);
                        }
                        /**
                         * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
                         */
                        modifier ifAdmin() {
                            if (msg.sender == _getAdmin()) {
                                _;
                            } else {
                                _fallback();
                            }
                        }
                        /**
                         * @dev Returns the current admin.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
                         */
                        function admin() external ifAdmin returns (address admin_) {
                            admin_ = _getAdmin();
                        }
                        /**
                         * @dev Returns the current implementation.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
                         *
                         * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                         * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                         * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
                         */
                        function implementation() external ifAdmin returns (address implementation_) {
                            implementation_ = _implementation();
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
                         */
                        function upgradeTo(address newImplementation) external ifAdmin {
                            _upgradeToAndCall(newImplementation, bytes(""), false);
                        }
                        /**
                         * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
                         * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
                         * proxied contract.
                         *
                         * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
                         */
                        function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
                            _upgradeToAndCall(newImplementation, data, true);
                        }
                        /**
                         * @dev Returns the current admin.
                         */
                        function _admin() internal view virtual returns (address) {
                            return _getAdmin();
                        }
                        /**
                         * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
                         */
                        function _beforeFallback() internal virtual override {
                            require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
                            super._beforeFallback();
                        }
                        function _getAdmin() internal view virtual override returns (address) {
                            return _ADMIN;
                        }
                    }
                    

                    File 9 of 9: TreasuryV2
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity 0.7.6;
                    import "./interfaces/ILayerZeroTreasury.sol";
                    import "@openzeppelin/contracts/access/Ownable.sol";
                    import "@openzeppelin/contracts/math/SafeMath.sol";
                    import "./interfaces/ILayerZeroUltraLightNodeV2.sol";
                    contract TreasuryV2 is ILayerZeroTreasury, Ownable {
                        using SafeMath for uint;
                        uint public nativeBP;
                        uint public zroFee;
                        bool public feeEnabled;
                        bool public zroEnabled;
                        ILayerZeroUltraLightNodeV2 public uln;
                        event NativeBP(uint bp);
                        event ZroFee(uint zroFee);
                        event FeeEnabled(bool feeEnabled);
                        event ZroEnabled(bool zroEnabled);
                        constructor(address _ulnv2) {
                            uln = ILayerZeroUltraLightNodeV2(_ulnv2);
                        }
                        function getFees(bool payInZro, uint relayerFee, uint oracleFee) external view override returns (uint) {
                            if (feeEnabled) {
                                if (payInZro) {
                                    require(zroEnabled, "LayerZero: ZRO is not enabled");
                                    return zroFee;
                                } else {
                                    return relayerFee.add(oracleFee).mul(nativeBP).div(10000);
                                }
                            }
                            return 0;
                        }
                        function setFeeEnabled(bool _feeEnabled) external onlyOwner {
                            feeEnabled = _feeEnabled;
                            emit FeeEnabled(_feeEnabled);
                        }
                        function setZroEnabled(bool _zroEnabled) external onlyOwner {
                            zroEnabled = _zroEnabled;
                            emit ZroEnabled(_zroEnabled);
                        }
                        function setNativeBP(uint _nativeBP) external onlyOwner {
                            nativeBP = _nativeBP;
                            emit NativeBP(_nativeBP);
                        }
                        function setZroFee(uint _zroFee) external onlyOwner {
                            zroFee = _zroFee;
                            emit ZroFee(_zroFee);
                        }
                        function withdrawZROFromULN(address _to, uint _amount) external onlyOwner {
                            uln.withdrawZRO(_to, _amount);
                        }
                        function withdrawNativeFromULN(address payable _to, uint _amount) external onlyOwner {
                            uln.withdrawNative(_to, _amount);
                        }
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.5.0;
                    interface ILayerZeroTreasury {
                        function getFees(bool payInZro, uint relayerFee, uint oracleFee) external view returns (uint);
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    import "../utils/Context.sol";
                    /**
                     * @dev Contract module which provides a basic access control mechanism, where
                     * there is an account (an owner) that can be granted exclusive access to
                     * specific functions.
                     *
                     * By default, the owner account will be the one that deploys the contract. This
                     * can later be changed with {transferOwnership}.
                     *
                     * This module is used through inheritance. It will make available the modifier
                     * `onlyOwner`, which can be applied to your functions to restrict their use to
                     * the owner.
                     */
                    abstract contract Ownable is Context {
                        address private _owner;
                        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
                        /**
                         * @dev Initializes the contract setting the deployer as the initial owner.
                         */
                        constructor () {
                            address msgSender = _msgSender();
                            _owner = msgSender;
                            emit OwnershipTransferred(address(0), msgSender);
                        }
                        /**
                         * @dev Returns the address of the current owner.
                         */
                        function owner() public view virtual returns (address) {
                            return _owner;
                        }
                        /**
                         * @dev Throws if called by any account other than the owner.
                         */
                        modifier onlyOwner() {
                            require(owner() == _msgSender(), "Ownable: caller is not the owner");
                            _;
                        }
                        /**
                         * @dev Leaves the contract without owner. It will not be possible to call
                         * `onlyOwner` functions anymore. Can only be called by the current owner.
                         *
                         * NOTE: Renouncing ownership will leave the contract without an owner,
                         * thereby removing any functionality that is only available to the owner.
                         */
                        function renounceOwnership() public virtual onlyOwner {
                            emit OwnershipTransferred(_owner, address(0));
                            _owner = address(0);
                        }
                        /**
                         * @dev Transfers ownership of the contract to a new account (`newOwner`).
                         * Can only be called by the current owner.
                         */
                        function transferOwnership(address newOwner) public virtual onlyOwner {
                            require(newOwner != address(0), "Ownable: new owner is the zero address");
                            emit OwnershipTransferred(_owner, newOwner);
                            _owner = newOwner;
                        }
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity ^0.7.0;
                    /**
                     * @dev Wrappers over Solidity's arithmetic operations with added overflow
                     * checks.
                     *
                     * Arithmetic operations in Solidity wrap on overflow. This can easily result
                     * in bugs, because programmers usually assume that an overflow raises an
                     * error, which is the standard behavior in high level programming languages.
                     * `SafeMath` restores this intuition by reverting the transaction when an
                     * operation overflows.
                     *
                     * Using this library instead of the unchecked operations eliminates an entire
                     * class of bugs, so it's recommended to use it always.
                     */
                    library SafeMath {
                        /**
                         * @dev Returns the addition of two unsigned integers, with an overflow flag.
                         *
                         * _Available since v3.4._
                         */
                        function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
                            uint256 c = a + b;
                            if (c < a) return (false, 0);
                            return (true, c);
                        }
                        /**
                         * @dev Returns the substraction of two unsigned integers, with an overflow flag.
                         *
                         * _Available since v3.4._
                         */
                        function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
                            if (b > a) return (false, 0);
                            return (true, a - b);
                        }
                        /**
                         * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
                         *
                         * _Available since v3.4._
                         */
                        function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
                            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
                            // benefit is lost if 'b' is also tested.
                            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
                            if (a == 0) return (true, 0);
                            uint256 c = a * b;
                            if (c / a != b) return (false, 0);
                            return (true, c);
                        }
                        /**
                         * @dev Returns the division of two unsigned integers, with a division by zero flag.
                         *
                         * _Available since v3.4._
                         */
                        function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
                            if (b == 0) return (false, 0);
                            return (true, a / b);
                        }
                        /**
                         * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
                         *
                         * _Available since v3.4._
                         */
                        function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
                            if (b == 0) return (false, 0);
                            return (true, a % b);
                        }
                        /**
                         * @dev Returns the addition of two unsigned integers, reverting on
                         * overflow.
                         *
                         * Counterpart to Solidity's `+` operator.
                         *
                         * Requirements:
                         *
                         * - Addition cannot overflow.
                         */
                        function add(uint256 a, uint256 b) internal pure returns (uint256) {
                            uint256 c = a + b;
                            require(c >= a, "SafeMath: addition overflow");
                            return c;
                        }
                        /**
                         * @dev Returns the subtraction of two unsigned integers, reverting on
                         * overflow (when the result is negative).
                         *
                         * Counterpart to Solidity's `-` operator.
                         *
                         * Requirements:
                         *
                         * - Subtraction cannot overflow.
                         */
                        function sub(uint256 a, uint256 b) internal pure returns (uint256) {
                            require(b <= a, "SafeMath: subtraction overflow");
                            return a - b;
                        }
                        /**
                         * @dev Returns the multiplication of two unsigned integers, reverting on
                         * overflow.
                         *
                         * Counterpart to Solidity's `*` operator.
                         *
                         * Requirements:
                         *
                         * - Multiplication cannot overflow.
                         */
                        function mul(uint256 a, uint256 b) internal pure returns (uint256) {
                            if (a == 0) return 0;
                            uint256 c = a * b;
                            require(c / a == b, "SafeMath: multiplication overflow");
                            return c;
                        }
                        /**
                         * @dev Returns the integer division of two unsigned integers, reverting on
                         * division by zero. The result is rounded towards zero.
                         *
                         * Counterpart to Solidity's `/` operator. Note: this function uses a
                         * `revert` opcode (which leaves remaining gas untouched) while Solidity
                         * uses an invalid opcode to revert (consuming all remaining gas).
                         *
                         * Requirements:
                         *
                         * - The divisor cannot be zero.
                         */
                        function div(uint256 a, uint256 b) internal pure returns (uint256) {
                            require(b > 0, "SafeMath: division by zero");
                            return a / b;
                        }
                        /**
                         * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
                         * reverting when dividing by zero.
                         *
                         * Counterpart to Solidity's `%` operator. This function uses a `revert`
                         * opcode (which leaves remaining gas untouched) while Solidity uses an
                         * invalid opcode to revert (consuming all remaining gas).
                         *
                         * Requirements:
                         *
                         * - The divisor cannot be zero.
                         */
                        function mod(uint256 a, uint256 b) internal pure returns (uint256) {
                            require(b > 0, "SafeMath: modulo by zero");
                            return a % b;
                        }
                        /**
                         * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
                         * overflow (when the result is negative).
                         *
                         * CAUTION: This function is deprecated because it requires allocating memory for the error
                         * message unnecessarily. For custom revert reasons use {trySub}.
                         *
                         * Counterpart to Solidity's `-` operator.
                         *
                         * Requirements:
                         *
                         * - Subtraction cannot overflow.
                         */
                        function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
                            require(b <= a, errorMessage);
                            return a - b;
                        }
                        /**
                         * @dev Returns the integer division of two unsigned integers, reverting with custom message on
                         * division by zero. The result is rounded towards zero.
                         *
                         * CAUTION: This function is deprecated because it requires allocating memory for the error
                         * message unnecessarily. For custom revert reasons use {tryDiv}.
                         *
                         * Counterpart to Solidity's `/` operator. Note: this function uses a
                         * `revert` opcode (which leaves remaining gas untouched) while Solidity
                         * uses an invalid opcode to revert (consuming all remaining gas).
                         *
                         * Requirements:
                         *
                         * - The divisor cannot be zero.
                         */
                        function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
                            require(b > 0, errorMessage);
                            return a / b;
                        }
                        /**
                         * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
                         * reverting with custom message when dividing by zero.
                         *
                         * CAUTION: This function is deprecated because it requires allocating memory for the error
                         * message unnecessarily. For custom revert reasons use {tryMod}.
                         *
                         * Counterpart to Solidity's `%` operator. This function uses a `revert`
                         * opcode (which leaves remaining gas untouched) while Solidity uses an
                         * invalid opcode to revert (consuming all remaining gas).
                         *
                         * Requirements:
                         *
                         * - The divisor cannot be zero.
                         */
                        function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
                            require(b > 0, errorMessage);
                            return a % b;
                        }
                    }
                    // SPDX-License-Identifier: BUSL-1.1
                    pragma solidity >=0.7.0;
                    pragma abicoder v2;
                    interface ILayerZeroUltraLightNodeV2 {
                        // Relayer functions
                        function validateTransactionProof(uint16 _srcChainId, address _dstAddress, uint _gasLimit, bytes32 _lookupHash, bytes32 _blockData, bytes calldata _transactionProof) external;
                        // an Oracle delivers the block data using updateHash()
                        function updateHash(uint16 _srcChainId, bytes32 _lookupHash, uint _confirmations, bytes32 _blockData) external;
                        // can only withdraw the receivable of the msg.sender
                        function withdrawNative(address payable _to, uint _amount) external;
                        function withdrawZRO(address _to, uint _amount) external;
                        // view functions
                        function getAppConfig(uint16 _remoteChainId, address _userApplicationAddress) external view returns (ApplicationConfiguration memory);
                        function accruedNativeFee(address _address) external view returns (uint);
                        struct ApplicationConfiguration {
                            uint16 inboundProofLibraryVersion;
                            uint64 inboundBlockConfirmations;
                            address relayer;
                            uint16 outboundProofType;
                            uint64 outboundBlockConfirmations;
                            address oracle;
                        }
                        event HashReceived(uint16 indexed srcChainId, address indexed oracle, bytes32 lookupHash, bytes32 blockData, uint confirmations);
                        event RelayerParams(bytes adapterParams, uint16 outboundProofType);
                        event Packet(bytes payload);
                        event InvalidDst(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);
                        event PacketReceived(uint16 indexed srcChainId, bytes srcAddress, address indexed dstAddress, uint64 nonce, bytes32 payloadHash);
                        event AppConfigUpdated(address indexed userApplication, uint indexed configType, bytes newConfig);
                        event AddInboundProofLibraryForChain(uint16 indexed chainId, address lib);
                        event EnableSupportedOutboundProof(uint16 indexed chainId, uint16 proofType);
                        event SetChainAddressSize(uint16 indexed chainId, uint size);
                        event SetDefaultConfigForChainId(uint16 indexed chainId, uint16 inboundProofLib, uint64 inboundBlockConfirm, address relayer, uint16 outboundProofType, uint64 outboundBlockConfirm, address oracle);
                        event SetDefaultAdapterParamsForChainId(uint16 indexed chainId, uint16 indexed proofType, bytes adapterParams);
                        event SetLayerZeroToken(address indexed tokenAddress);
                        event SetRemoteUln(uint16 indexed chainId, bytes32 uln);
                        event SetTreasury(address indexed treasuryAddress);
                        event WithdrawZRO(address indexed msgSender, address indexed to, uint amount);
                        event WithdrawNative(address indexed msgSender, address indexed to, uint amount);
                    }
                    // SPDX-License-Identifier: MIT
                    pragma solidity >=0.6.0 <0.8.0;
                    /*
                     * @dev Provides information about the current execution context, including the
                     * sender of the transaction and its data. While these are generally available
                     * via msg.sender and msg.data, they should not be accessed in such a direct
                     * manner, since when dealing with GSN meta-transactions the account sending and
                     * paying for execution may not be the actual sender (as far as an application
                     * is concerned).
                     *
                     * This contract is only required for intermediate, library-like contracts.
                     */
                    abstract contract Context {
                        function _msgSender() internal view virtual returns (address payable) {
                            return msg.sender;
                        }
                        function _msgData() internal view virtual returns (bytes memory) {
                            this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
                            return msg.data;
                        }
                    }