@layerzerolabs/lz-evm-sdk-v2 2.3.8 → 2.3.9

package/deployments/polygon-sandbox-local/ExecutorDecompressor.json

@@ -211,7 +211,7 @@
       "type": "function"
     }
   ],
-  "transactionHash": "0x30ab2f9ac539719ed18edcfb17f7ec19b3a0161db517d76e83fda7deeb6b76fc",
+  "transactionHash": "0xca8445fd297b96f2b421bf62eab07d78cdcc3fbd5c6d1d44867fd9f6f36fc61c",
   "receipt": {
     "to": null,
     "from": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
@@ -219,13 +219,13 @@
     "transactionIndex": 0,
     "gasUsed": "1359743",
     "logsBloom": "0x00000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000100000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000020000000000000000000800000800000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000200002000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000",
-    "blockHash": "0x4572b2eb428d3530f18198953efdb6e3a4adb4c4cee5c1b160e4453632a4e4ec",
-    "transactionHash": "0x30ab2f9ac539719ed18edcfb17f7ec19b3a0161db517d76e83fda7deeb6b76fc",
+    "blockHash": "0xacf6f515460680f950027fa0e6cafd24b875cf40531206c506c5b59a3c3946e5",
+    "transactionHash": "0xca8445fd297b96f2b421bf62eab07d78cdcc3fbd5c6d1d44867fd9f6f36fc61c",
     "logs": [
       {
         "transactionIndex": 0,
         "blockNumber": 44,
-        "transactionHash": "0x30ab2f9ac539719ed18edcfb17f7ec19b3a0161db517d76e83fda7deeb6b76fc",
+        "transactionHash": "0xca8445fd297b96f2b421bf62eab07d78cdcc3fbd5c6d1d44867fd9f6f36fc61c",
         "address": "0x5F1e91d509cFEB544809B0749284DEB25C3a113a",
         "topics": [
           "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
@@ -234,7 +234,7 @@
         ],
         "data": "0x",
         "logIndex": 0,
-        "blockHash": "0x4572b2eb428d3530f18198953efdb6e3a4adb4c4cee5c1b160e4453632a4e4ec"
+        "blockHash": "0xacf6f515460680f950027fa0e6cafd24b875cf40531206c506c5b59a3c3946e5"
       }
     ],
     "blockNumber": 44,
@@ -246,7 +246,7 @@
     "0x36B22905A1211A55E0d62eF46720172e2b0f24BD"
   ],
   "numDeployments": 1,
-  "solcInputHash": "081ec8fe84772fc61ae510a169ad8d59",
+  "solcInputHash": "72bb6280e8e5b284c7ae61d40992d7e4",
   "metadata": "{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract Executor\",\"name\":\"_executor\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"IncorrectDictAccess\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_DICT_LEN\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"RESERVE_DICT_LEN\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decompress\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decompressed\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"raw\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_encoded\",\"type\":\"bytes\"}],\"name\":\"execute301\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"executor\",\"outputs\":[{\"internalType\":\"contract Executor\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"begin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"end\",\"type\":\"uint256\"}],\"name\":\"getData\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"res\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_encoded\",\"type\":\"bytes\"}],\"name\":\"nativeDrop\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_encoded\",\"type\":\"bytes\"}],\"name\":\"nativeDropAndExecute301\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_encoded\",\"type\":\"bytes\"}],\"name\":\"nativeDropAndExecute302\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"IncorrectDictAccess(uint256)\":[{\"details\":\"Emitted when an offset is used incorrectly, either because it is too small, or because its sum with a dict data's length exceeds a certain limit.\",\"params\":{\"value\":\"The incorrect value used as an offset or as the sum of the offset and a dict data's length.\"}}]},\"kind\":\"dev\",\"methods\":{\"decompress()\":{\"details\":\"Decompresses the compressed data (N bytes) passed to the function using the _delegatecall function.\"},\"decompressed()\":{\"details\":\"Calculates and returns the decompressed data from the compressed calldata.\",\"returns\":{\"raw\":\"The decompressed raw data.\"}},\"getData(uint256,uint256)\":{\"details\":\"Returns the data stored in the dictionary in the specified range.\",\"params\":{\"begin\":\"The starting index of the data range to return. First 2 positions are reserved, so it should be greater than 1.\",\"end\":\"The ending index of the data range to return.\"},\"returns\":{\"res\":\"An array of bytes32 values containing the data in the specified range.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/decompressor/ExecutorDecompressor.sol\":\"ExecutorDecompressor\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":20000},\"remappings\":[]},\"sources\":{\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport { IMessageLibManager } from \\\"./IMessageLibManager.sol\\\";\\nimport { IMessagingComposer } from \\\"./IMessagingComposer.sol\\\";\\nimport { IMessagingChannel } from \\\"./IMessagingChannel.sol\\\";\\nimport { IMessagingContext } from \\\"./IMessagingContext.sol\\\";\\n\\nstruct MessagingParams {\\n    uint32 dstEid;\\n    bytes32 receiver;\\n    bytes message;\\n    bytes options;\\n    bool payInLzToken;\\n}\\n\\nstruct MessagingReceipt {\\n    bytes32 guid;\\n    uint64 nonce;\\n    MessagingFee fee;\\n}\\n\\nstruct MessagingFee {\\n    uint256 nativeFee;\\n    uint256 lzTokenFee;\\n}\\n\\nstruct Origin {\\n    uint32 srcEid;\\n    bytes32 sender;\\n    uint64 nonce;\\n}\\n\\ninterface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {\\n    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);\\n\\n    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);\\n\\n    event PacketDelivered(Origin origin, address receiver);\\n\\n    event LzReceiveAlert(\\n        address indexed receiver,\\n        address indexed executor,\\n        Origin origin,\\n        bytes32 guid,\\n        uint256 gas,\\n        uint256 value,\\n        bytes message,\\n        bytes extraData,\\n        bytes reason\\n    );\\n\\n    event LzTokenSet(address token);\\n\\n    event DelegateSet(address sender, address delegate);\\n\\n    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);\\n\\n    function send(\\n        MessagingParams calldata _params,\\n        address _refundAddress\\n    ) external payable returns (MessagingReceipt memory);\\n\\n    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;\\n\\n    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);\\n\\n    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);\\n\\n    function lzReceive(\\n        Origin calldata _origin,\\n        address _receiver,\\n        bytes32 _guid,\\n        bytes calldata _message,\\n        bytes calldata _extraData\\n    ) external payable;\\n\\n    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order\\n    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;\\n\\n    function setLzToken(address _lzToken) external;\\n\\n    function lzToken() external view returns (address);\\n\\n    function nativeToken() external view returns (address);\\n\\n    function setDelegate(address _delegate) external;\\n}\\n\",\"keccak256\":\"0xf7f941bee89ea6369950fe54e8ac476ae6478b958b20fc0e8a83e8ff1364eac3\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport { IERC165 } from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\n\\nimport { SetConfigParam } from \\\"./IMessageLibManager.sol\\\";\\n\\nenum MessageLibType {\\n    Send,\\n    Receive,\\n    SendAndReceive\\n}\\n\\ninterface IMessageLib is IERC165 {\\n    function setConfig(address _oapp, SetConfigParam[] calldata _config) external;\\n\\n    function getConfig(uint32 _eid, address _oapp, uint32 _configType) external view returns (bytes memory config);\\n\\n    function isSupportedEid(uint32 _eid) external view returns (bool);\\n\\n    // message libs of same major version are compatible\\n    function version() external view returns (uint64 major, uint8 minor, uint8 endpointVersion);\\n\\n    function messageLibType() external view returns (MessageLibType);\\n}\\n\",\"keccak256\":\"0x5cf5f24751b4e3ea1c9c5ded07cedfdfd62566b6daaffcc0144733859c9dba0c\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessageLibManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nstruct SetConfigParam {\\n    uint32 eid;\\n    uint32 configType;\\n    bytes config;\\n}\\n\\ninterface IMessageLibManager {\\n    struct Timeout {\\n        address lib;\\n        uint256 expiry;\\n    }\\n\\n    event LibraryRegistered(address newLib);\\n    event DefaultSendLibrarySet(uint32 eid, address newLib);\\n    event DefaultReceiveLibrarySet(uint32 eid, address newLib);\\n    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);\\n    event SendLibrarySet(address sender, uint32 eid, address newLib);\\n    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);\\n    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);\\n\\n    function registerLibrary(address _lib) external;\\n\\n    function isRegisteredLibrary(address _lib) external view returns (bool);\\n\\n    function getRegisteredLibraries() external view returns (address[] memory);\\n\\n    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;\\n\\n    function defaultSendLibrary(uint32 _eid) external view returns (address);\\n\\n    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _gracePeriod) external;\\n\\n    function defaultReceiveLibrary(uint32 _eid) external view returns (address);\\n\\n    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;\\n\\n    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);\\n\\n    function isSupportedEid(uint32 _eid) external view returns (bool);\\n\\n    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);\\n\\n    /// ------------------- OApp interfaces -------------------\\n    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;\\n\\n    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);\\n\\n    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);\\n\\n    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;\\n\\n    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);\\n\\n    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _expiry) external;\\n\\n    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);\\n\\n    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;\\n\\n    function getConfig(\\n        address _oapp,\\n        address _lib,\\n        uint32 _eid,\\n        uint32 _configType\\n    ) external view returns (bytes memory config);\\n}\\n\",\"keccak256\":\"0x919b37133adff4dc528e3061deb2789c3149971b530c61e556fb3d09ab315dfc\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessagingChannel.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface IMessagingChannel {\\n    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);\\n    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);\\n    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);\\n\\n    function eid() external view returns (uint32);\\n\\n    // this is an emergency function if a message cannot be verified for some reasons\\n    // required to provide _nextNonce to avoid race condition\\n    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;\\n\\n    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;\\n\\n    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;\\n\\n    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);\\n\\n    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);\\n\\n    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);\\n\\n    function inboundPayloadHash(\\n        address _receiver,\\n        uint32 _srcEid,\\n        bytes32 _sender,\\n        uint64 _nonce\\n    ) external view returns (bytes32);\\n\\n    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);\\n}\\n\",\"keccak256\":\"0x0878f64dffebf58c4165569416372f40860fab546b88cd926eba0d5cb6d8d972\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessagingComposer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface IMessagingComposer {\\n    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);\\n    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);\\n    event LzComposeAlert(\\n        address indexed from,\\n        address indexed to,\\n        address indexed executor,\\n        bytes32 guid,\\n        uint16 index,\\n        uint256 gas,\\n        uint256 value,\\n        bytes message,\\n        bytes extraData,\\n        bytes reason\\n    );\\n\\n    function composeQueue(\\n        address _from,\\n        address _to,\\n        bytes32 _guid,\\n        uint16 _index\\n    ) external view returns (bytes32 messageHash);\\n\\n    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;\\n\\n    function lzCompose(\\n        address _from,\\n        address _to,\\n        bytes32 _guid,\\n        uint16 _index,\\n        bytes calldata _message,\\n        bytes calldata _extraData\\n    ) external payable;\\n}\\n\",\"keccak256\":\"0x85bc7090134529ec474866dc4bb1c48692d518c756eb0a961c82574829c51901\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/IMessagingContext.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface IMessagingContext {\\n    function isSendingMessage() external view returns (bool);\\n\\n    function getSendContext() external view returns (uint32 dstEid, address sender);\\n}\\n\",\"keccak256\":\"0xff0c546c2813dae3e440882f46b377375f7461b0714efd80bd3f0c6e5cb8da4e\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport { MessagingFee } from \\\"./ILayerZeroEndpointV2.sol\\\";\\nimport { IMessageLib } from \\\"./IMessageLib.sol\\\";\\n\\nstruct Packet {\\n    uint64 nonce;\\n    uint32 srcEid;\\n    address sender;\\n    uint32 dstEid;\\n    bytes32 receiver;\\n    bytes32 guid;\\n    bytes message;\\n}\\n\\ninterface ISendLib is IMessageLib {\\n    function send(\\n        Packet calldata _packet,\\n        bytes calldata _options,\\n        bool _payInLzToken\\n    ) external returns (MessagingFee memory, bytes memory encodedPacket);\\n\\n    function quote(\\n        Packet calldata _packet,\\n        bytes calldata _options,\\n        bool _payInLzToken\\n    ) external view returns (MessagingFee memory);\\n\\n    function setTreasury(address _treasury) external;\\n\\n    function withdrawFee(address _to, uint256 _amount) external;\\n\\n    function withdrawLzTokenFee(address _lzToken, address _to, uint256 _amount) external;\\n}\\n\",\"keccak256\":\"0xf1c07bc61e7b1dce195ed12d50f87980fbf2d63cac1326fd28287f55fe0ba625\",\"license\":\"MIT\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/libs/AddressCast.sol\":{\"content\":\"// SPDX-License-Identifier: LZBL-1.2\\n\\npragma solidity ^0.8.20;\\n\\nlibrary AddressCast {\\n    error AddressCast_InvalidSizeForAddress();\\n    error AddressCast_InvalidAddress();\\n\\n    function toBytes32(bytes calldata _addressBytes) internal pure returns (bytes32 result) {\\n        if (_addressBytes.length > 32) revert AddressCast_InvalidAddress();\\n        result = bytes32(_addressBytes);\\n        unchecked {\\n            uint256 offset = 32 - _addressBytes.length;\\n            result = result >> (offset * 8);\\n        }\\n    }\\n\\n    function toBytes32(address _address) internal pure returns (bytes32 result) {\\n        result = bytes32(uint256(uint160(_address)));\\n    }\\n\\n    function toBytes(bytes32 _addressBytes32, uint256 _size) internal pure returns (bytes memory result) {\\n        if (_size == 0 || _size > 32) revert AddressCast_InvalidSizeForAddress();\\n        result = new bytes(_size);\\n        unchecked {\\n            uint256 offset = 256 - _size * 8;\\n            assembly {\\n                mstore(add(result, 32), shl(offset, _addressBytes32))\\n            }\\n        }\\n    }\\n\\n    function toAddress(bytes32 _addressBytes32) internal pure returns (address result) {\\n        result = address(uint160(uint256(_addressBytes32)));\\n    }\\n\\n    function toAddress(bytes calldata _addressBytes) internal pure returns (address result) {\\n        if (_addressBytes.length != 20) revert AddressCast_InvalidAddress();\\n        result = address(bytes20(_addressBytes));\\n    }\\n}\\n\",\"keccak256\":\"0x2ebbcaaab3554edcd41b581f1a72ac1806afbfb8047d0d47ff098f9af30d6deb\",\"license\":\"LZBL-1.2\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol\":{\"content\":\"// SPDX-License-Identifier: LZBL-1.2\\n\\npragma solidity ^0.8.20;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\nlibrary Transfer {\\n    using SafeERC20 for IERC20;\\n\\n    address internal constant ADDRESS_ZERO = address(0);\\n\\n    error Transfer_NativeFailed(address _to, uint256 _value);\\n    error Transfer_ToAddressIsZero();\\n\\n    function native(address _to, uint256 _value) internal {\\n        if (_to == ADDRESS_ZERO) revert Transfer_ToAddressIsZero();\\n        (bool success, ) = _to.call{ value: _value }(\\\"\\\");\\n        if (!success) revert Transfer_NativeFailed(_to, _value);\\n    }\\n\\n    function token(address _token, address _to, uint256 _value) internal {\\n        if (_to == ADDRESS_ZERO) revert Transfer_ToAddressIsZero();\\n        IERC20(_token).safeTransfer(_to, _value);\\n    }\\n\\n    function nativeOrToken(address _token, address _to, uint256 _value) internal {\\n        if (_token == ADDRESS_ZERO) {\\n            native(_to, _value);\\n        } else {\\n            token(_token, _to, _value);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x621d6dd5b8b7e827351459fff4ac87c16ba4656757592cf67de8b199aea4cf9a\",\"license\":\"LZBL-1.2\"},\"@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol\":{\"content\":\"// SPDX-License-Identifier: LZBL-1.2\\n\\npragma solidity ^0.8.20;\\n\\nimport { Packet } from \\\"../../interfaces/ISendLib.sol\\\";\\nimport { AddressCast } from \\\"../../libs/AddressCast.sol\\\";\\n\\nlibrary PacketV1Codec {\\n    using AddressCast for address;\\n    using AddressCast for bytes32;\\n\\n    uint8 internal constant PACKET_VERSION = 1;\\n\\n    // header (version + nonce + path)\\n    // version\\n    uint256 private constant PACKET_VERSION_OFFSET = 0;\\n    //    nonce\\n    uint256 private constant NONCE_OFFSET = 1;\\n    //    path\\n    uint256 private constant SRC_EID_OFFSET = 9;\\n    uint256 private constant SENDER_OFFSET = 13;\\n    uint256 private constant DST_EID_OFFSET = 45;\\n    uint256 private constant RECEIVER_OFFSET = 49;\\n    // payload (guid + message)\\n    uint256 private constant GUID_OFFSET = 81; // keccak256(nonce + path)\\n    uint256 private constant MESSAGE_OFFSET = 113;\\n\\n    function encode(Packet memory _packet) internal pure returns (bytes memory encodedPacket) {\\n        encodedPacket = abi.encodePacked(\\n            PACKET_VERSION,\\n            _packet.nonce,\\n            _packet.srcEid,\\n            _packet.sender.toBytes32(),\\n            _packet.dstEid,\\n            _packet.receiver,\\n            _packet.guid,\\n            _packet.message\\n        );\\n    }\\n\\n    function encodePacketHeader(Packet memory _packet) internal pure returns (bytes memory) {\\n        return\\n            abi.encodePacked(\\n                PACKET_VERSION,\\n                _packet.nonce,\\n                _packet.srcEid,\\n                _packet.sender.toBytes32(),\\n                _packet.dstEid,\\n                _packet.receiver\\n            );\\n    }\\n\\n    function encodePayload(Packet memory _packet) internal pure returns (bytes memory) {\\n        return abi.encodePacked(_packet.guid, _packet.message);\\n    }\\n\\n    function header(bytes calldata _packet) internal pure returns (bytes calldata) {\\n        return _packet[0:GUID_OFFSET];\\n    }\\n\\n    function version(bytes calldata _packet) internal pure returns (uint8) {\\n        return uint8(bytes1(_packet[PACKET_VERSION_OFFSET:NONCE_OFFSET]));\\n    }\\n\\n    function nonce(bytes calldata _packet) internal pure returns (uint64) {\\n        return uint64(bytes8(_packet[NONCE_OFFSET:SRC_EID_OFFSET]));\\n    }\\n\\n    function srcEid(bytes calldata _packet) internal pure returns (uint32) {\\n        return uint32(bytes4(_packet[SRC_EID_OFFSET:SENDER_OFFSET]));\\n    }\\n\\n    function sender(bytes calldata _packet) internal pure returns (bytes32) {\\n        return bytes32(_packet[SENDER_OFFSET:DST_EID_OFFSET]);\\n    }\\n\\n    function senderAddressB20(bytes calldata _packet) internal pure returns (address) {\\n        return sender(_packet).toAddress();\\n    }\\n\\n    function dstEid(bytes calldata _packet) internal pure returns (uint32) {\\n        return uint32(bytes4(_packet[DST_EID_OFFSET:RECEIVER_OFFSET]));\\n    }\\n\\n    function receiver(bytes calldata _packet) internal pure returns (bytes32) {\\n        return bytes32(_packet[RECEIVER_OFFSET:GUID_OFFSET]);\\n    }\\n\\n    function receiverB20(bytes calldata _packet) internal pure returns (address) {\\n        return receiver(_packet).toAddress();\\n    }\\n\\n    function guid(bytes calldata _packet) internal pure returns (bytes32) {\\n        return bytes32(_packet[GUID_OFFSET:MESSAGE_OFFSET]);\\n    }\\n\\n    function message(bytes calldata _packet) internal pure returns (bytes calldata) {\\n        return bytes(_packet[MESSAGE_OFFSET:]);\\n    }\\n\\n    function payload(bytes calldata _packet) internal pure returns (bytes calldata) {\\n        return bytes(_packet[GUID_OFFSET:]);\\n    }\\n\\n    function payloadHash(bytes calldata _packet) internal pure returns (bytes32) {\\n        return keccak256(payload(_packet));\\n    }\\n}\\n\",\"keccak256\":\"0xc84cf1bf785977fe1fbe7566eef902c2db68d0e163813ebe6c34921754802680\",\"license\":\"LZBL-1.2\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAccessControlUpgradeable.sol\\\";\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```solidity\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```solidity\\n * function foo() public {\\n *     require(hasRole(MY_ROLE, msg.sender));\\n *     ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\\n * to enforce additional security measures for this role.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n    struct RoleData {\\n        mapping(address => bool) members;\\n        bytes32 adminRole;\\n    }\\n\\n    mapping(bytes32 => RoleData) private _roles;\\n\\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n    /**\\n     * @dev Modifier that checks that an account has a specific role. Reverts\\n     * with a standardized message including the required role.\\n     *\\n     * The format of the revert reason is given by the following regular expression:\\n     *\\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n     *\\n     * _Available since v4.1._\\n     */\\n    modifier onlyRole(bytes32 role) {\\n        _checkRole(role);\\n        _;\\n    }\\n\\n    function __AccessControl_init() internal onlyInitializing {\\n    }\\n\\n    function __AccessControl_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev See {IERC165-supportsInterface}.\\n     */\\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\\n    }\\n\\n    /**\\n     * @dev Returns `true` if `account` has been granted `role`.\\n     */\\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\\n        return _roles[role].members[account];\\n    }\\n\\n    /**\\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\\n     *\\n     * Format of the revert message is described in {_checkRole}.\\n     *\\n     * _Available since v4.6._\\n     */\\n    function _checkRole(bytes32 role) internal view virtual {\\n        _checkRole(role, _msgSender());\\n    }\\n\\n    /**\\n     * @dev Revert with a standard message if `account` is missing `role`.\\n     *\\n     * The format of the revert reason is given by the following regular expression:\\n     *\\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n     */\\n    function _checkRole(bytes32 role, address account) internal view virtual {\\n        if (!hasRole(role, account)) {\\n            revert(\\n                string(\\n                    abi.encodePacked(\\n                        \\\"AccessControl: account \\\",\\n                        StringsUpgradeable.toHexString(account),\\n                        \\\" is missing role \\\",\\n                        StringsUpgradeable.toHexString(uint256(role), 32)\\n                    )\\n                )\\n            );\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\\n     * {revokeRole}.\\n     *\\n     * To change a role's admin, use {_setRoleAdmin}.\\n     */\\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\\n        return _roles[role].adminRole;\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     *\\n     * May emit a {RoleGranted} event.\\n     */\\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n        _grantRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n        _revokeRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from the calling account.\\n     *\\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n     * purpose is to provide a mechanism for accounts to lose their privileges\\n     * if they are compromised (such as when a trusted device is misplaced).\\n     *\\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `account`.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function renounceRole(bytes32 role, address account) public virtual override {\\n        require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n        _revokeRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event. Note that unlike {grantRole}, this function doesn't perform any\\n     * checks on the calling account.\\n     *\\n     * May emit a {RoleGranted} event.\\n     *\\n     * [WARNING]\\n     * ====\\n     * This function should only be called from the constructor when setting\\n     * up the initial roles for the system.\\n     *\\n     * Using this function in any other way is effectively circumventing the admin\\n     * system imposed by {AccessControl}.\\n     * ====\\n     *\\n     * NOTE: This function is deprecated in favor of {_grantRole}.\\n     */\\n    function _setupRole(bytes32 role, address account) internal virtual {\\n        _grantRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Sets `adminRole` as ``role``'s admin role.\\n     *\\n     * Emits a {RoleAdminChanged} event.\\n     */\\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n        bytes32 previousAdminRole = getRoleAdmin(role);\\n        _roles[role].adminRole = adminRole;\\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * Internal function without access restriction.\\n     *\\n     * May emit a {RoleGranted} event.\\n     */\\n    function _grantRole(bytes32 role, address account) internal virtual {\\n        if (!hasRole(role, account)) {\\n            _roles[role].members[account] = true;\\n            emit RoleGranted(role, account, _msgSender());\\n        }\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * Internal function without access restriction.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function _revokeRole(bytes32 role, address account) internal virtual {\\n        if (hasRole(role, account)) {\\n            _roles[role].members[account] = false;\\n            emit RoleRevoked(role, account, _msgSender());\\n        }\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xc8710577334e8d0799ae2b2a731b1924a7bddd64319da9787ddd2dc69bdd1ce5\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n    /**\\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n     *\\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n     * {RoleAdminChanged} not being emitted signaling this.\\n     *\\n     * _Available since v3.1._\\n     */\\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `role`.\\n     *\\n     * `sender` is the account that originated the contract call, an admin role\\n     * bearer except when using {AccessControl-_setupRole}.\\n     */\\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n    /**\\n     * @dev Emitted when `account` is revoked `role`.\\n     *\\n     * `sender` is the account that originated the contract call:\\n     *   - if using `revokeRole`, it is the admin role bearer\\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n     */\\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n    /**\\n     * @dev Returns `true` if `account` has been granted `role`.\\n     */\\n    function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n    /**\\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\\n     * {revokeRole}.\\n     *\\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n     */\\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     */\\n    function grantRole(bytes32 role, address account) external;\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     */\\n    function revokeRole(bytes32 role, address account) external;\\n\\n    /**\\n     * @dev Revokes `role` from the calling account.\\n     *\\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n     * purpose is to provide a mechanism for accounts to lose their privileges\\n     * if they are compromised (such as when a trusted device is misplaced).\\n     *\\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `account`.\\n     */\\n    function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0xb8f5302f12138c5561362e88a78d061573e6298b7a1a5afe84a1e2c8d4d5aeaa\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n     * constructor.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized != type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint8) {\\n        return _initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _initializing;\\n    }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n    /**\\n     * @dev Emitted when the pause is triggered by `account`.\\n     */\\n    event Paused(address account);\\n\\n    /**\\n     * @dev Emitted when the pause is lifted by `account`.\\n     */\\n    event Unpaused(address account);\\n\\n    bool private _paused;\\n\\n    /**\\n     * @dev Initializes the contract in unpaused state.\\n     */\\n    function __Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __Pausable_init_unchained() internal onlyInitializing {\\n        _paused = false;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is not paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    modifier whenNotPaused() {\\n        _requireNotPaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    modifier whenPaused() {\\n        _requirePaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns true if the contract is paused, and false otherwise.\\n     */\\n    function paused() public view virtual returns (bool) {\\n        return _paused;\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is paused.\\n     */\\n    function _requireNotPaused() internal view virtual {\\n        require(!paused(), \\\"Pausable: paused\\\");\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is not paused.\\n     */\\n    function _requirePaused() internal view virtual {\\n        require(paused(), \\\"Pausable: not paused\\\");\\n    }\\n\\n    /**\\n     * @dev Triggers stopped state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    function _pause() internal virtual whenNotPaused {\\n        _paused = true;\\n        emit Paused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns to normal state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    function _unpause() internal virtual whenPaused {\\n        _paused = false;\\n        emit Unpaused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xad32f6821f860555f9530902a65b54203a4f5db2117f4384ae47a124958078db\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\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 ReentrancyGuardUpgradeable is Initializable {\\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's contents, replace the bits taken up by the boolean, and then write\\n    // back. This is the compiler's 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's 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    function __ReentrancyGuard_init() internal onlyInitializing {\\n        __ReentrancyGuard_init_unchained();\\n    }\\n\\n    function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\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 making it call a\\n     * `private` function that does the actual work.\\n     */\\n    modifier nonReentrant() {\\n        _nonReentrantBefore();\\n        _;\\n        _nonReentrantAfter();\\n    }\\n\\n    function _nonReentrantBefore() private {\\n        // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n        require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = _ENTERED;\\n    }\\n\\n    function _nonReentrantAfter() private {\\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    /**\\n     * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n     * `nonReentrant` function in the call stack.\\n     */\\n    function _reentrancyGuardEntered() internal view returns (bool) {\\n        return _status == _ENTERED;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x2025ccf05f6f1f2fd4e078e552836f525a1864e3854ed555047cd732320ab29b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\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     * Furthermore, `isContract` will also return true if the target contract within\\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n     * which only has an effect at the end of a transaction.\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `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://consensys.net/diligence/blog/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.8.0/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 >= amount, \\\"Address: insufficient balance\\\");\\n\\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 functionCallWithValue(target, data, 0, \\\"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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) 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(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, 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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, 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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.delegatecall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-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\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\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 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 ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x75097e35253e7fb282ee4d7f27a80eaacfa759923185bf17302a89cbc059c5ef\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/MathUpgradeable.sol\\\";\\nimport \\\"./math/SignedMathUpgradeable.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n    bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n    uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            uint256 length = MathUpgradeable.log10(value) + 1;\\n            string memory buffer = new string(length);\\n            uint256 ptr;\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                ptr := add(buffer, add(32, length))\\n            }\\n            while (true) {\\n                ptr--;\\n                /// @solidity memory-safe-assembly\\n                assembly {\\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n                }\\n                value /= 10;\\n                if (value == 0) break;\\n            }\\n            return buffer;\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(int256 value) internal pure returns (string memory) {\\n        return string(abi.encodePacked(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMathUpgradeable.abs(value))));\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n     */\\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(2 * length + 2);\\n        buffer[0] = \\\"0\\\";\\n        buffer[1] = \\\"x\\\";\\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\\n            buffer[i] = _SYMBOLS[value & 0xf];\\n            value >>= 4;\\n        }\\n        require(value == 0, \\\"Strings: hex length insufficient\\\");\\n        return string(buffer);\\n    }\\n\\n    /**\\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(address addr) internal pure returns (string memory) {\\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n    }\\n\\n    /**\\n     * @dev Returns true if the two strings are equal.\\n     */\\n    function equal(string memory a, string memory b) internal pure returns (bool) {\\n        return keccak256(bytes(a)) == keccak256(bytes(b));\\n    }\\n}\\n\",\"keccak256\":\"0xb96dc79b65b7c37937919dcdb356a969ce0aa2e8338322bf4dc027a3c9c9a7eb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n    function __ERC165_init() internal onlyInitializing {\\n    }\\n\\n    function __ERC165_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev See {IERC165-supportsInterface}.\\n     */\\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0xd90d7723512df65ae417adaf0801042940f0dabd60039ceeaffe34aa5b238da1\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary MathUpgradeable {\\n    enum Rounding {\\n        Down, // Toward negative infinity\\n        Up, // Toward infinity\\n        Zero // Toward zero\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds up instead\\n     * of rounding down.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b - 1) / b can overflow on addition, so we distribute.\\n        return a == 0 ? 0 : (a - 1) / b + 1;\\n    }\\n\\n    /**\\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n     * with further edits by Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2^256 + prod0.\\n            uint256 prod0; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod0 := mul(x, y)\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n            require(denominator > prod1, \\\"Math: mulDiv overflow\\\");\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n            // See https://cs.stackexchange.com/q/138556/92363.\\n\\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\\n            uint256 twos = denominator & (~denominator + 1);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv = 1 mod 2^4.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n            // in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        uint256 result = mulDiv(x, y, denominator);\\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n            result += 1;\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n     *\\n     * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        if (a == 0) {\\n            return 0;\\n        }\\n\\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n        //\\n        // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n        //\\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n        // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n        // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n        //\\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n        uint256 result = 1 << (log2(a) >> 1);\\n\\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n        // into the expected uint128 result.\\n        unchecked {\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            return min(result, a / result);\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 128;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 64;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 32;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 16;\\n            }\\n            if (value >> 8 > 0) {\\n                value >>= 8;\\n                result += 8;\\n            }\\n            if (value >> 4 > 0) {\\n                value >>= 4;\\n                result += 4;\\n            }\\n            if (value >> 2 > 0) {\\n                value >>= 2;\\n                result += 2;\\n            }\\n            if (value >> 1 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 16;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 8;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 4;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 2;\\n            }\\n            if (value >> 8 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2bc0007987c229ae7624eb29be6a9b84f6a6a5872f76248b15208b131ea41c4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMathUpgradeable {\\n    /**\\n     * @dev Returns the largest of two signed numbers.\\n     */\\n    function max(int256 a, int256 b) internal pure returns (int256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two signed numbers.\\n     */\\n    function min(int256 a, int256 b) internal pure returns (int256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two signed numbers without overflow.\\n     * The result is rounded towards zero.\\n     */\\n    function average(int256 a, int256 b) internal pure returns (int256) {\\n        // Formula from the book \\\"Hacker's Delight\\\"\\n        int256 x = (a & b) + ((a ^ b) >> 1);\\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\\n    }\\n\\n    /**\\n     * @dev Returns the absolute unsigned value of a signed value.\\n     */\\n    function abs(int256 n) internal pure returns (uint256) {\\n        unchecked {\\n            // must be unchecked in order to support `n = type(int256).min`\\n            return uint256(n >= 0 ? n : -n);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x88f6b7bba3ee33eeb741f9a0f5bc98b6e6e352d0fe4905377bb328590f84095a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\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        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\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 the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby disabling any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(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        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n}\\n\",\"keccak256\":\"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\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    /**\\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's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, 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's 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's 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 `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n *     doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n *     token.safeTransferFrom(msg.sender, address(this), value);\\n *     ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n    /**\\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n     * given ``owner``'s signed approval.\\n     *\\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n     * ordering also apply here.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `deadline` must be a timestamp in the future.\\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n     * over the EIP712-formatted function arguments.\\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\\n     *\\n     * For more information on the signature format, see the\\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n     * section].\\n     *\\n     * CAUTION: See Security Considerations above.\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /**\\n     * @dev Returns the current nonce for `owner`. This value must be\\n     * included whenever a signature is generated for {permit}.\\n     *\\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n     * prevents a signature from being used multiple times.\\n     */\\n    function nonces(address owner) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/IERC20Permit.sol\\\";\\nimport \\\"../../../utils/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 Address for address;\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\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        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n        require(\\n            (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    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        unchecked {\\n            uint256 oldAllowance = token.allowance(address(this), spender);\\n            require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n     * Revert on invalid signature.\\n     */\\n    function safePermit(\\n        IERC20Permit token,\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal {\\n        uint256 nonceBefore = token.nonces(owner);\\n        token.permit(owner, spender, value, deadline, v, r, s);\\n        uint256 nonceAfter = token.nonces(owner);\\n        require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\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's return data size checking mechanism, since\\n        // we're 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        require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\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     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n        // and not revert is the subcall reverts.\\n\\n        (bool success, bytes memory returndata) = address(token).call(data);\\n        return\\n            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\\n    }\\n}\\n\",\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\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     * Furthermore, `isContract` will also return true if the target contract within\\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n     * which only has an effect at the end of a transaction.\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `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://consensys.net/diligence/blog/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.8.0/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 >= amount, \\\"Address: insufficient balance\\\");\\n\\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 functionCallWithValue(target, data, 0, \\\"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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) 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(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, 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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, 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(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.delegatecall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-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\",\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\\n\\npragma solidity ^0.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 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) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"contracts/Executor.sol\":{\"content\":\"// SPDX-License-Identifier: LZBL-1.2\\n\\npragma solidity ^0.8.20;\\n\\nimport { ReentrancyGuardUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport { Proxied } from \\\"hardhat-deploy/solc_0.8/proxy/Proxied.sol\\\";\\n\\nimport { Origin } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol\\\";\\nimport { PacketV1Codec } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/PacketV1Codec.sol\\\";\\n\\nimport { IUltraLightNode301 } from \\\"./uln/uln301/interfaces/IUltraLightNode301.sol\\\";\\nimport { IExecutor } from \\\"./interfaces/IExecutor.sol\\\";\\nimport { IExecutorFeeLib } from \\\"./interfaces/IExecutorFeeLib.sol\\\";\\nimport { WorkerUpgradeable } from \\\"./upgradeable/WorkerUpgradeable.sol\\\";\\n\\ninterface ILayerZeroEndpointV2 {\\n    function eid() external view returns (uint32);\\n\\n    function lzReceive(\\n        Origin calldata _origin,\\n        address _receiver,\\n        bytes32 _guid,\\n        bytes calldata _message,\\n        bytes calldata _extraData\\n    ) external payable;\\n\\n    function lzReceiveAlert(\\n        Origin calldata _origin,\\n        address _receiver,\\n        bytes32 _guid,\\n        uint256 _gas,\\n        uint256 _value,\\n        bytes calldata _message,\\n        bytes calldata _extraData,\\n        bytes calldata _reason\\n    ) external;\\n\\n    function lzCompose(\\n        address _from,\\n        address _to,\\n        bytes32 _guid,\\n        uint16 _index,\\n        bytes calldata _message,\\n        bytes calldata _extraData\\n    ) external payable;\\n\\n    function lzComposeAlert(\\n        address _from,\\n        address _to,\\n        bytes32 _guid,\\n        uint16 _index,\\n        uint256 _gas,\\n        uint256 _value,\\n        bytes calldata _message,\\n        bytes calldata _extraData,\\n        bytes calldata _reason\\n    ) external;\\n}\\n\\ncontract Executor is WorkerUpgradeable, ReentrancyGuardUpgradeable, Proxied, IExecutor {\\n    using PacketV1Codec for bytes;\\n\\n    mapping(uint32 dstEid => DstConfig) public dstConfig;\\n\\n    // endpoint v2\\n    address public endpoint;\\n    uint32 public localEid;\\n\\n    // endpoint v1\\n    address public receiveUln301;\\n\\n    function initialize(\\n        address _endpoint,\\n        address _receiveUln301,\\n        address[] memory _messageLibs,\\n        address _priceFeed,\\n        address _roleAdmin,\\n        address[] memory _admins\\n    ) external proxied initializer {\\n        __ReentrancyGuard_init();\\n        __Worker_init(_messageLibs, _priceFeed, 12000, _roleAdmin, _admins);\\n        endpoint = _endpoint;\\n        localEid = ILayerZeroEndpointV2(_endpoint).eid();\\n        receiveUln301 = _receiveUln301;\\n    }\\n\\n    function onUpgrade(address _receiveUln301) external proxied {\\n        receiveUln301 = _receiveUln301;\\n    }\\n\\n    // --- Admin ---\\n    function setDstConfig(DstConfigParam[] memory _params) external onlyRole(ADMIN_ROLE) {\\n        for (uint256 i = 0; i < _params.length; i++) {\\n            DstConfigParam memory param = _params[i];\\n            dstConfig[param.dstEid] = DstConfig(\\n                param.lzReceiveBaseGas,\\n                param.multiplierBps,\\n                param.floorMarginUSD,\\n                param.nativeCap,\\n                param.lzComposeBaseGas\\n            );\\n        }\\n        emit DstConfigSet(_params);\\n    }\\n\\n    function nativeDrop(\\n        Origin calldata _origin,\\n        uint32 _dstEid,\\n        address _oapp,\\n        NativeDropParams[] calldata _nativeDropParams,\\n        uint256 _nativeDropGasLimit\\n    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {\\n        _nativeDrop(_origin, _dstEid, _oapp, _nativeDropParams, _nativeDropGasLimit);\\n    }\\n\\n    function nativeDropAndExecute301(\\n        Origin calldata _origin,\\n        NativeDropParams[] calldata _nativeDropParams,\\n        uint256 _nativeDropGasLimit,\\n        bytes calldata _packet,\\n        uint256 _gasLimit\\n    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {\\n        _nativeDrop(_origin, _packet.dstEid(), _packet.receiverB20(), _nativeDropParams, _nativeDropGasLimit);\\n        IUltraLightNode301(receiveUln301).commitVerification(_packet, _gasLimit);\\n    }\\n\\n    function execute301(bytes calldata _packet, uint256 _gasLimit) external onlyRole(ADMIN_ROLE) nonReentrant {\\n        IUltraLightNode301(receiveUln301).commitVerification(_packet, _gasLimit);\\n    }\\n\\n    function execute302(ExecutionParams calldata _executionParams) external payable onlyRole(ADMIN_ROLE) nonReentrant {\\n        try\\n            ILayerZeroEndpointV2(endpoint).lzReceive{ value: msg.value, gas: _executionParams.gasLimit }(\\n                _executionParams.origin,\\n                _executionParams.receiver,\\n                _executionParams.guid,\\n                _executionParams.message,\\n                _executionParams.extraData\\n            )\\n        {\\n            // do nothing\\n        } catch (bytes memory reason) {\\n            ILayerZeroEndpointV2(endpoint).lzReceiveAlert(\\n                _executionParams.origin,\\n                _executionParams.receiver,\\n                _executionParams.guid,\\n                _executionParams.gasLimit,\\n                msg.value,\\n                _executionParams.message,\\n                _executionParams.extraData,\\n                reason\\n            );\\n        }\\n    }\\n\\n    function compose302(\\n        address _from,\\n        address _to,\\n        bytes32 _guid,\\n        uint16 _index,\\n        bytes calldata _message,\\n        bytes calldata _extraData,\\n        uint256 _gasLimit\\n    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {\\n        try\\n            ILayerZeroEndpointV2(endpoint).lzCompose{ value: msg.value, gas: _gasLimit }(\\n                _from,\\n                _to,\\n                _guid,\\n                _index,\\n                _message,\\n                _extraData\\n            )\\n        {\\n            // do nothing\\n        } catch (bytes memory reason) {\\n            ILayerZeroEndpointV2(endpoint).lzComposeAlert(\\n                _from,\\n                _to,\\n                _guid,\\n                _index,\\n                _gasLimit,\\n                msg.value,\\n                _message,\\n                _extraData,\\n                reason\\n            );\\n        }\\n    }\\n\\n    function nativeDropAndExecute302(\\n        NativeDropParams[] calldata _nativeDropParams,\\n        uint256 _nativeDropGasLimit,\\n        ExecutionParams calldata _executionParams\\n    ) external payable onlyRole(ADMIN_ROLE) nonReentrant {\\n        uint256 spent = _nativeDrop(\\n            _executionParams.origin,\\n            localEid,\\n            _executionParams.receiver,\\n            _nativeDropParams,\\n            _nativeDropGasLimit\\n        );\\n\\n        uint256 value = msg.value - spent;\\n        try\\n            ILayerZeroEndpointV2(endpoint).lzReceive{ value: value, gas: _executionParams.gasLimit }(\\n                _executionParams.origin,\\n                _executionParams.receiver,\\n                _executionParams.guid,\\n                _executionParams.message,\\n                _executionParams.extraData\\n            )\\n        {\\n            // do nothing\\n        } catch (bytes memory reason) {\\n            ILayerZeroEndpointV2(endpoint).lzReceiveAlert(\\n                _executionParams.origin,\\n                _executionParams.receiver,\\n                _executionParams.guid,\\n                _executionParams.gasLimit,\\n                value,\\n                _executionParams.message,\\n                _executionParams.extraData,\\n                reason\\n            );\\n        }\\n    }\\n\\n    // --- Message Lib ---\\n    function assignJob(\\n        uint32 _dstEid,\\n        address _sender,\\n        uint256 _calldataSize,\\n        bytes calldata _options\\n    ) external onlyRole(MESSAGE_LIB_ROLE) onlyAcl(_sender) whenNotPaused returns (uint256 fee) {\\n        IExecutorFeeLib.FeeParams memory params = IExecutorFeeLib.FeeParams(\\n            priceFeed,\\n            _dstEid,\\n            _sender,\\n            _calldataSize,\\n            defaultMultiplierBps\\n        );\\n        fee = IExecutorFeeLib(workerFeeLib).getFeeOnSend(params, dstConfig[_dstEid], _options);\\n    }\\n\\n    // --- Only ACL ---\\n    function getFee(\\n        uint32 _dstEid,\\n        address _sender,\\n        uint256 _calldataSize,\\n        bytes calldata _options\\n    ) external view onlyAcl(_sender) whenNotPaused returns (uint256 fee) {\\n        IExecutorFeeLib.FeeParams memory params = IExecutorFeeLib.FeeParams(\\n            priceFeed,\\n            _dstEid,\\n            _sender,\\n            _calldataSize,\\n            defaultMultiplierBps\\n        );\\n        fee = IExecutorFeeLib(workerFeeLib).getFee(params, dstConfig[_dstEid], _options);\\n    }\\n\\n    function _nativeDrop(\\n        Origin calldata _origin,\\n        uint32 _dstEid,\\n        address _oapp,\\n        NativeDropParams[] calldata _nativeDropParams,\\n        uint256 _nativeDropGasLimit\\n    ) internal returns (uint256 spent) {\\n        bool[] memory success = new bool[](_nativeDropParams.length);\\n        for (uint256 i = 0; i < _nativeDropParams.length; i++) {\\n            NativeDropParams memory param = _nativeDropParams[i];\\n\\n            (bool sent, ) = param.receiver.call{ value: param.amount, gas: _nativeDropGasLimit }(\\\"\\\");\\n\\n            success[i] = sent;\\n            spent += param.amount;\\n        }\\n        emit NativeDropApplied(_origin, _dstEid, _oapp, _nativeDropParams, success);\\n    }\\n}\\n\",\"keccak256\":\"0x173732fb4910788881e755ee1d3d6b0d84b732a887179a13ebc34cbac90c9fc2\",\"license\":\"LZBL-1.2\"},\"contracts/decompressor/DecompressorExtension.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @title DecompressorExtension\\n * @dev A contract that implements a decompression algorithm to be used in conjunction with compressed data.\\n * You should implement in your contract a function that makes use of the internal methods `_setData`, `_setDataArray` for data addition to the dictionary.\\n * NOTE: It is important to implement a delay when using the `_setData` and `_setDataArray` methods in your transactions. This delay helps to guard against the possibility of frontrunning, which can occur when the state of the dictionary changes during the execution of a transaction.\\n * @notice This extension could result in a much higher gas consumption than expected and could potentially lead to significant memory expansion costs. Be sure to properly estimate these aspects to avoid unforeseen expenses.\\n */\\nabstract contract DecompressorExtension {\\n    /**\\n     * @dev Emitted when an offset is used incorrectly, either because it is too small, or because its sum with a dict data's length exceeds a certain limit.\\n     * @param value The incorrect value used as an offset or as the sum of the offset and a dict data's length.\\n     */\\n    error IncorrectDictAccess(uint256 value);\\n\\n    uint256 public constant MAX_DICT_LEN = 1_048_576; // 2 ** 20\\n    uint256 public constant RESERVE_DICT_LEN = 2; // 0: msg.sender; 1: address(this)\\n\\n    /**\\n     * @dev The dictionary mapping storage slots to their associated compressed data.\\n     */\\n    bytes32[MAX_DICT_LEN] private _dict;\\n\\n    /**\\n     * @dev Ensures the provided value is correctly used as an offset. This includes checks for the offset being too small or its sum with an dict data's length exceeding a certain limit. Value less `RESERVE_DICT_LEN` are reserved.\\n     * @param value The value used as an offset or as the sum of the offset and an array's length.\\n     */\\n    modifier validDictAccess(uint256 value) {\\n        if (value < RESERVE_DICT_LEN || value >= MAX_DICT_LEN) revert IncorrectDictAccess(value);\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the data stored in the dictionary in the specified range.\\n     * @param begin The starting index of the data range to return. First 2 positions are reserved, so it should be greater than 1.\\n     * @param end The ending index of the data range to return.\\n     * @return res An array of bytes32 values containing the data in the specified range.\\n     */\\n    function getData(\\n        uint256 begin,\\n        uint256 end\\n    ) external view validDictAccess(begin) validDictAccess(end) returns (bytes32[] memory res) {\\n        unchecked {\\n            if (begin < end) {\\n                res = new bytes32[](end - begin);\\n                for (uint256 i = begin; i < end; i++) {\\n                    res[i - begin] = _dict[i];\\n                }\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Sets the data at the specified dictionary offset.\\n     * @param offset The dictionary offset to set the data at. First 2 positions are reserved, so it should be greater than 1.\\n     * @param data The data to be stored at the specified offset.\\n     */\\n    function _setData(uint256 offset, bytes32 data) internal validDictAccess(offset) {\\n        unchecked {\\n            _dict[offset] = data;\\n        }\\n    }\\n\\n    /**\\n     * @dev Sets an array of data starting at the specified dictionary offset.\\n     * @param offset The starting dictionary offset to set the data at. First 2 positions are reserved, so it should be greater than 1.\\n     * @param dataArray The array of data to be stored starting at the specified offset.\\n     */\\n    function _setDataArray(\\n        uint256 offset,\\n        bytes32[] calldata dataArray\\n    ) internal validDictAccess(offset) validDictAccess(offset + dataArray.length) {\\n        unchecked {\\n            for (uint256 i = 0; i < dataArray.length; i++) {\\n                _dict[offset + i] = dataArray[i];\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Decompresses the compressed data (N bytes) passed to the function using the _delegatecall function.\\n     */\\n    function decompress() external payable {\\n        _delegatecall(decompressed());\\n    }\\n\\n    /**\\n     * @dev Calculates and returns the decompressed data from the compressed calldata.\\n     * @return raw The decompressed raw data.\\n     */\\n    function decompressed() public view returns (bytes memory raw) {\\n        return _decompressed(msg.data[4:]);\\n    }\\n\\n    /**\\n     * @dev Calculates and returns the decompressed raw data from the compressed data passed as an argument.\\n     * @param cd The compressed data to be decompressed.\\n     * @return raw The decompressed raw data.\\n     */\\n    function _decompressed(bytes calldata cd) internal view returns (bytes memory raw) {\\n        assembly (\\\"memory-safe\\\") {\\n            // solhint-disable-line no-inline-assembly\\n            raw := mload(0x40)\\n            let outptr := add(raw, 0x20)\\n            let end := add(cd.offset, cd.length)\\n            for {\\n                let inptr := cd.offset\\n            } lt(inptr, end) {\\n\\n            } {\\n                // solhint-disable-line no-empty-blocks\\n                let data := calldataload(inptr)\\n\\n                let key\\n\\n                // 00XXXXXX - insert X+1 zero bytes\\n                // 01PXXXXX - copy X+1 bytes calldata (P means padding to 32 bytes or not)\\n                // 10BBXXXX XXXXXXXX - use 12 bits as key for [32,20,4,31][B] bytes from storage X\\n                // 11BBXXXX XXXXXXXX XXXXXXXX - use 20 bits as [32,20,4,31][B] bytes from storage X\\n                switch shr(254, data)\\n                case 0 {\\n                    let size := add(byte(0, data), 1)\\n                    calldatacopy(outptr, calldatasize(), size)\\n                    inptr := add(inptr, 1)\\n                    outptr := add(outptr, size)\\n                    continue\\n                }\\n                case 1 {\\n                    let size := add(and(0x1F, byte(0, data)), 1)\\n                    if and(data, 0x2000000000000000000000000000000000000000000000000000000000000000) {\\n                        mstore(outptr, 0)\\n                        outptr := add(outptr, sub(32, size))\\n                    }\\n                    calldatacopy(outptr, add(inptr, 1), size)\\n                    inptr := add(inptr, add(1, size))\\n                    outptr := add(outptr, size)\\n                    continue\\n                }\\n                case 2 {\\n                    key := shr(244, shl(4, data))\\n                    inptr := add(inptr, 2)\\n                    // fallthrough\\n                }\\n                case 3 {\\n                    key := shr(236, shl(4, data))\\n                    inptr := add(inptr, 3)\\n                    // fallthrough\\n                }\\n\\n                // TODO: check sload argument\\n                let value\\n                switch key\\n                case 0 {\\n                    value := caller()\\n                }\\n                case 1 {\\n                    value := address()\\n                }\\n                default {\\n                    value := sload(add(_dict.slot, key))\\n                }\\n\\n                switch shr(254, shl(2, data))\\n                case 0 {\\n                    mstore(outptr, value)\\n                    outptr := add(outptr, 32)\\n                }\\n                case 1 {\\n                    mstore(outptr, shl(96, value))\\n                    outptr := add(outptr, 20)\\n                }\\n                case 2 {\\n                    mstore(outptr, shl(224, value))\\n                    outptr := add(outptr, 4)\\n                }\\n                default {\\n                    mstore(outptr, shl(8, value))\\n                    outptr := add(outptr, 31)\\n                }\\n            }\\n            mstore(raw, sub(sub(outptr, raw), 0x20))\\n            mstore(0x40, outptr)\\n        }\\n    }\\n\\n    /**\\n     * @dev Executes a delegate call to the raw data calculated by the _decompressed function.\\n     * @param raw The raw data to execute the delegate call with.\\n     */\\n    function _delegatecall(bytes memory raw) internal {\\n        assembly (\\\"memory-safe\\\") {\\n            // solhint-disable-line no-inline-assembly\\n            let success := delegatecall(gas(), address(), add(raw, 0x20), mload(raw), 0, 0)\\n            returndatacopy(0, 0, returndatasize())\\n            if success {\\n                return(0, returndatasize())\\n            }\\n            revert(0, returndatasize())\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x992dbf52168e93f95e8ed4b558215c3dfbfc8c914f09bfefb7ca056b7a739d9f\",\"license\":\"MIT\"},\"contracts/decompressor/ExecutorDecoder.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity ^0.8.0;\\n\\nimport { Origin } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol\\\";\\nimport { IExecutor } from \\\"../interfaces/IExecutor.sol\\\";\\n\\nlibrary ExecutorDecoder {\\n    uint8 internal constant NATIVE_DROP_GAS_LIMIT_OFFSET = 0; // uint32\\n    uint8 internal constant SRC_EID_OFFSET = 4; // uint32\\n    uint8 internal constant SENDER_OFFSET = 8; // bytes32\\n    uint8 internal constant NONCE_OFFSET = 40; // uint64\\n    uint8 internal constant RECEIVER_OFFSET = 48; // address\\n\\n    uint8 internal constant NATIVEDROP_DST_EID_OFFSET = 68; // uint32\\n    uint8 internal constant DST_EID_SIZE = 4; // uint32\\n    function nativeDrop(\\n        bytes calldata _encoded\\n    )\\n        internal\\n        pure\\n        returns (\\n            Origin memory origin,\\n            uint32 dstEid,\\n            address receiver,\\n            IExecutor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit\\n        )\\n    {\\n        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));\\n        origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));\\n        origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);\\n        origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:RECEIVER_OFFSET]));\\n        receiver = address(bytes20(_encoded[RECEIVER_OFFSET:NATIVEDROP_DST_EID_OFFSET]));\\n\\n        uint8 nativeDropOffset = NATIVEDROP_DST_EID_OFFSET + DST_EID_SIZE;\\n        dstEid = uint32(bytes4(_encoded[NATIVEDROP_DST_EID_OFFSET:nativeDropOffset]));\\n\\n        nativeDropParams = _nativeDrop(_encoded[nativeDropOffset:]);\\n    }\\n\\n    uint8 internal constant EXECUTE301_GAS_LIMIT_OFFSET = 0; // uint64\\n    uint8 internal constant EXECUTE301_PACKET_OFFSET = 8; // uint64\\n    function execute301(bytes calldata encoded) internal pure returns (bytes memory packet, uint256 gasLimit) {\\n        gasLimit = uint256(uint64(bytes8(encoded[EXECUTE301_GAS_LIMIT_OFFSET:EXECUTE301_PACKET_OFFSET])));\\n        packet = encoded[EXECUTE301_PACKET_OFFSET:];\\n    }\\n\\n    uint8 internal constant NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET = 48; // uint64\\n    uint8 internal constant NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET = 56; // uint64\\n    uint8 internal constant NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET = 64; // uint64\\n    function nativeDropAndExecute301(\\n        bytes calldata _encoded\\n    )\\n        internal\\n        pure\\n        returns (\\n            Origin memory origin,\\n            IExecutor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit,\\n            bytes memory packet,\\n            uint256 gasLimit\\n        )\\n    {\\n        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));\\n        origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));\\n        origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);\\n        origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET]));\\n\\n        gasLimit = uint256(\\n            uint64(\\n                bytes8(\\n                    _encoded[NATIVEDROP_AND_EXECUTE301_GAS_LIMIT_OFFSET:NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET]\\n                )\\n            )\\n        );\\n\\n        uint64 packetLength = uint64(\\n            bytes8(_encoded[NATIVEDROP_AND_EXECUTE301_PACKET_LENGTH_OFFSET:NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET])\\n        );\\n\\n        uint256 cursor = NATIVEDROP_AND_EXECUTE301_PACKET_OFFSET;\\n\\n        packet = _encoded[cursor:cursor + packetLength];\\n        cursor += packetLength;\\n\\n        nativeDropParams = _nativeDrop(_encoded[cursor:]);\\n    }\\n\\n    uint8 internal constant EXECUTE302_GUID_OFFSET = 68; // bytes32\\n    uint8 internal constant EXECUTE302_GAS_LIMIT_OFFSET = 100; // uint64\\n    uint8 internal constant EXECUTE302_MESSAGE_LENGTH_OFFSET = 108; // uint64\\n    uint8 internal constant EXECUTE302_MESSAGE_OFFSET = 116; // uint64\\n    uint8 internal constant EXTRA_DATA_LENGTH_SIZE = 8; // uint64\\n    function nativeDropAndExecute302(\\n        bytes calldata _encoded\\n    )\\n        internal\\n        pure\\n        returns (\\n            IExecutor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit,\\n            IExecutor.ExecutionParams memory executionParams\\n        )\\n    {\\n        nativeDropGasLimit = uint256(uint32(bytes4(_encoded[NATIVE_DROP_GAS_LIMIT_OFFSET:SRC_EID_OFFSET])));\\n        executionParams.origin.srcEid = uint32(bytes4(_encoded[SRC_EID_OFFSET:SENDER_OFFSET]));\\n        executionParams.origin.sender = bytes32(_encoded[SENDER_OFFSET:NONCE_OFFSET]);\\n        executionParams.origin.nonce = uint64(bytes8(_encoded[NONCE_OFFSET:RECEIVER_OFFSET]));\\n        executionParams.receiver = address(bytes20(_encoded[RECEIVER_OFFSET:EXECUTE302_GUID_OFFSET]));\\n        executionParams.guid = bytes32(_encoded[EXECUTE302_GUID_OFFSET:EXECUTE302_GAS_LIMIT_OFFSET]);\\n        executionParams.gasLimit = uint256(\\n            uint64(bytes8(_encoded[EXECUTE302_GAS_LIMIT_OFFSET:EXECUTE302_MESSAGE_LENGTH_OFFSET]))\\n        );\\n\\n        uint64 messageLength = uint64(bytes8(_encoded[EXECUTE302_MESSAGE_LENGTH_OFFSET:EXECUTE302_MESSAGE_OFFSET]));\\n        uint256 cursor = EXECUTE302_MESSAGE_OFFSET;\\n\\n        executionParams.message = _encoded[cursor:cursor + messageLength];\\n        cursor += messageLength;\\n\\n        uint64 extraDataLength = uint64(bytes8(_encoded[cursor:cursor + EXTRA_DATA_LENGTH_SIZE]));\\n        cursor += EXTRA_DATA_LENGTH_SIZE;\\n\\n        executionParams.extraData = _encoded[cursor:cursor + extraDataLength];\\n        cursor += extraDataLength;\\n\\n        nativeDropParams = _nativeDrop(_encoded[cursor:]);\\n    }\\n\\n    uint8 internal constant NATIVE_DROP_RECEIVER_SIZE = 20; // address\\n    uint8 internal constant NATIVE_DROP_AMOUNT_SIZE = 9; // uint72\\n    uint8 internal constant NATIVE_DROP_PARAM_SIZE = 29; // 20 + 9\\n    function _nativeDrop(\\n        bytes calldata _encoded\\n    ) internal pure returns (IExecutor.NativeDropParams[] memory nativeDropParams) {\\n        uint256 cursor = 0;\\n        uint256 nativeDropParamsLength = _encoded.length / NATIVE_DROP_PARAM_SIZE;\\n\\n        nativeDropParams = new IExecutor.NativeDropParams[](nativeDropParamsLength);\\n        for (uint256 i = 0; i < nativeDropParamsLength; i++) {\\n            nativeDropParams[i].receiver = address(bytes20(_encoded[cursor:cursor + NATIVE_DROP_RECEIVER_SIZE]));\\n            cursor += NATIVE_DROP_RECEIVER_SIZE;\\n            nativeDropParams[i].amount = uint256(uint72(bytes9(_encoded[cursor:cursor + NATIVE_DROP_AMOUNT_SIZE])));\\n            cursor += NATIVE_DROP_AMOUNT_SIZE;\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x7764bd65dae4145030859075a9e313f3e13f78d3715a379c7f5a06e682c41477\",\"license\":\"BUSL-1.1\"},\"contracts/decompressor/ExecutorDecompressor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity 0.8.22;\\n\\nimport { Ownable } from \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport { Origin } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol\\\";\\n\\nimport { Executor } from \\\"../Executor.sol\\\";\\nimport { ExecutorDecoder } from \\\"./ExecutorDecoder.sol\\\";\\nimport { DecompressorExtension } from \\\"./DecompressorExtension.sol\\\";\\n\\ncontract ExecutorDecompressor is Ownable, DecompressorExtension {\\n    Executor public immutable executor;\\n\\n    constructor(Executor _executor) {\\n        executor = _executor;\\n    }\\n\\n    function nativeDrop(bytes calldata _encoded) external onlyOwner {\\n        (\\n            Origin memory origin,\\n            uint32 dstEid,\\n            address oapp,\\n            Executor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit\\n        ) = ExecutorDecoder.nativeDrop(_encoded);\\n\\n        executor.nativeDrop(origin, dstEid, oapp, nativeDropParams, nativeDropGasLimit);\\n    }\\n\\n    function execute301(bytes calldata _encoded) external onlyOwner {\\n        (bytes memory packet, uint256 gasLimit) = ExecutorDecoder.execute301(_encoded);\\n\\n        executor.execute301(packet, gasLimit);\\n    }\\n\\n    function nativeDropAndExecute301(bytes calldata _encoded) external onlyOwner {\\n        (\\n            Origin memory origin,\\n            Executor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit,\\n            bytes memory packet,\\n            uint256 gasLimit\\n        ) = ExecutorDecoder.nativeDropAndExecute301(_encoded);\\n\\n        executor.nativeDropAndExecute301(origin, nativeDropParams, nativeDropGasLimit, packet, gasLimit);\\n    }\\n\\n    function nativeDropAndExecute302(bytes calldata _encoded) external onlyOwner {\\n        (\\n            Executor.NativeDropParams[] memory nativeDropParams,\\n            uint256 nativeDropGasLimit,\\n            Executor.ExecutionParams memory executionParams\\n        ) = ExecutorDecoder.nativeDropAndExecute302(_encoded);\\n\\n        executor.nativeDropAndExecute302(nativeDropParams, nativeDropGasLimit, executionParams);\\n    }\\n}\\n\",\"keccak256\":\"0x10dc451a10021b5700acfbbba333ca0e71b8ae98f41dd36ba85fe5ab8ad35160\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IExecutor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport { Origin } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol\\\";\\n\\nimport { IWorker } from \\\"./IWorker.sol\\\";\\nimport { ILayerZeroExecutor } from \\\"./ILayerZeroExecutor.sol\\\";\\n\\ninterface IExecutor is IWorker, ILayerZeroExecutor {\\n    struct DstConfigParam {\\n        uint32 dstEid;\\n        uint64 lzReceiveBaseGas;\\n        uint64 lzComposeBaseGas;\\n        uint16 multiplierBps;\\n        uint128 floorMarginUSD;\\n        uint128 nativeCap;\\n    }\\n\\n    struct DstConfig {\\n        uint64 lzReceiveBaseGas;\\n        uint16 multiplierBps;\\n        uint128 floorMarginUSD; // uses priceFeed PRICE_RATIO_DENOMINATOR\\n        uint128 nativeCap;\\n        uint64 lzComposeBaseGas;\\n    }\\n\\n    struct ExecutionParams {\\n        address receiver;\\n        Origin origin;\\n        bytes32 guid;\\n        bytes message;\\n        bytes extraData;\\n        uint256 gasLimit;\\n    }\\n\\n    struct NativeDropParams {\\n        address receiver;\\n        uint256 amount;\\n    }\\n\\n    event DstConfigSet(DstConfigParam[] params);\\n    event NativeDropApplied(Origin origin, uint32 dstEid, address oapp, NativeDropParams[] params, bool[] success);\\n\\n    function dstConfig(uint32 _dstEid) external view returns (uint64, uint16, uint128, uint128, uint64);\\n}\\n\",\"keccak256\":\"0xa0abbbde2d91fc80929bb3214eeb57ecd11cef99c6190bf31bdb9930fa16d14a\",\"license\":\"MIT\"},\"contracts/interfaces/IExecutorFeeLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\nimport { IExecutor } from \\\"./IExecutor.sol\\\";\\n\\ninterface IExecutorFeeLib {\\n    struct FeeParams {\\n        address priceFeed;\\n        uint32 dstEid;\\n        address sender;\\n        uint256 calldataSize;\\n        uint16 defaultMultiplierBps;\\n    }\\n\\n    error Executor_NoOptions();\\n    error Executor_NativeAmountExceedsCap(uint256 amount, uint256 cap);\\n    error Executor_UnsupportedOptionType(uint8 optionType);\\n    error Executor_InvalidExecutorOptions(uint256 cursor);\\n    error Executor_ZeroLzReceiveGasProvided();\\n    error Executor_ZeroLzComposeGasProvided();\\n    error Executor_EidNotSupported(uint32 eid);\\n\\n    function getFeeOnSend(\\n        FeeParams calldata _params,\\n        IExecutor.DstConfig calldata _dstConfig,\\n        bytes calldata _options\\n    ) external returns (uint256 fee);\\n\\n    function getFee(\\n        FeeParams calldata _params,\\n        IExecutor.DstConfig calldata _dstConfig,\\n        bytes calldata _options\\n    ) external view returns (uint256 fee);\\n}\\n\",\"keccak256\":\"0xf36091f40c969f83831fdf69f91b9ccf25237335bd2696dd18f1b721ddb794b3\",\"license\":\"MIT\"},\"contracts/interfaces/ILayerZeroExecutor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface ILayerZeroExecutor {\\n    // @notice query price and assign jobs at the same time\\n    // @param _dstEid - the destination endpoint identifier\\n    // @param _sender - the source sending contract address. executors may apply price discrimination to senders\\n    // @param _calldataSize - dynamic data size of message + caller params\\n    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain\\n    function assignJob(\\n        uint32 _dstEid,\\n        address _sender,\\n        uint256 _calldataSize,\\n        bytes calldata _options\\n    ) external returns (uint256 price);\\n\\n    // @notice query the executor price for relaying the payload and its proof to the destination chain\\n    // @param _dstEid - the destination endpoint identifier\\n    // @param _sender - the source sending contract address. executors may apply price discrimination to senders\\n    // @param _calldataSize - dynamic data size of message + caller params\\n    // @param _options - optional parameters for extra service plugins, e.g. sending dust tokens at the destination chain\\n    function getFee(\\n        uint32 _dstEid,\\n        address _sender,\\n        uint256 _calldataSize,\\n        bytes calldata _options\\n    ) external view returns (uint256 price);\\n}\\n\",\"keccak256\":\"0x3647af317ee126b1247a782abb30e59ec5ab21b4945f1d3b4370d1fa3c1bf347\",\"license\":\"MIT\"},\"contracts/interfaces/IWorker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface IWorker {\\n    event SetWorkerLib(address workerLib);\\n    event SetPriceFeed(address priceFeed);\\n    event SetDefaultMultiplierBps(uint16 multiplierBps);\\n    event SetSupportedOptionTypes(uint32 dstEid, uint8[] optionTypes);\\n    event Withdraw(address lib, address to, uint256 amount);\\n\\n    error Worker_NotAllowed();\\n    error Worker_OnlyMessageLib();\\n    error Worker_RoleRenouncingDisabled();\\n\\n    function setPriceFeed(address _priceFeed) external;\\n\\n    function priceFeed() external view returns (address);\\n\\n    function setDefaultMultiplierBps(uint16 _multiplierBps) external;\\n\\n    function defaultMultiplierBps() external view returns (uint16);\\n\\n    function withdrawFee(address _lib, address _to, uint256 _amount) external;\\n\\n    function setSupportedOptionTypes(uint32 _eid, uint8[] calldata _optionTypes) external;\\n\\n    function getSupportedOptionTypes(uint32 _eid) external view returns (uint8[] memory);\\n}\\n\",\"keccak256\":\"0xa6b61913767305227576cc6da5067de4208f09a4f58bfbfe32beafdfae9869b1\",\"license\":\"MIT\"},\"contracts/uln/uln301/interfaces/IUltraLightNode301.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.8.0;\\n\\ninterface IUltraLightNode301 {\\n    function commitVerification(bytes calldata _packet, uint256 _gasLimit) external;\\n}\\n\",\"keccak256\":\"0x47f8ebeaa7d96a6f337a18c46e3c532da578c7cb0a13fb6e6f014286b991902f\",\"license\":\"MIT\"},\"contracts/upgradeable/WorkerUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: LZBL-1.2\\n\\npragma solidity ^0.8.20;\\n\\nimport { PausableUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\nimport { AccessControlUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\nimport { Initializable } from \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\n\\nimport { ISendLib } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ISendLib.sol\\\";\\nimport { Transfer } from \\\"@layerzerolabs/lz-evm-protocol-v2/contracts/libs/Transfer.sol\\\";\\n\\nimport { IWorker } from \\\"../interfaces/IWorker.sol\\\";\\n\\nabstract contract WorkerUpgradeable is Initializable, AccessControlUpgradeable, PausableUpgradeable, IWorker {\\n    bytes32 internal constant MESSAGE_LIB_ROLE = keccak256(\\\"MESSAGE_LIB_ROLE\\\");\\n    bytes32 internal constant ALLOWLIST = keccak256(\\\"ALLOWLIST\\\");\\n    bytes32 internal constant DENYLIST = keccak256(\\\"DENYLIST\\\");\\n    bytes32 internal constant ADMIN_ROLE = keccak256(\\\"ADMIN_ROLE\\\");\\n\\n    address public workerFeeLib;\\n\\n    uint64 public allowlistSize;\\n    uint16 public defaultMultiplierBps;\\n    address public priceFeed;\\n\\n    mapping(uint32 eid => uint8[] optionTypes) internal supportedOptionTypes;\\n\\n    /// @param _messageLibs array of message lib addresses that are granted the MESSAGE_LIB_ROLE\\n    /// @param _priceFeed price feed address\\n    /// @param _defaultMultiplierBps default multiplier for worker fee\\n    /// @param _roleAdmin address that is granted the DEFAULT_ADMIN_ROLE (can grant and revoke all roles)\\n    /// @param _admins array of admin addresses that are granted the ADMIN_ROLE\\n    function __Worker_init(\\n        address[] memory _messageLibs,\\n        address _priceFeed,\\n        uint16 _defaultMultiplierBps,\\n        address _roleAdmin,\\n        address[] memory _admins\\n    ) internal onlyInitializing {\\n        __Context_init_unchained();\\n        __AccessControl_init_unchained();\\n        __Pausable_init_unchained();\\n        __Worker_init_unchained(_messageLibs, _priceFeed, _defaultMultiplierBps, _roleAdmin, _admins);\\n    }\\n\\n    function __Worker_init_unchained(\\n        address[] memory _messageLibs,\\n        address _priceFeed,\\n        uint16 _defaultMultiplierBps,\\n        address _roleAdmin,\\n        address[] memory _admins\\n    ) internal onlyInitializing {\\n        defaultMultiplierBps = _defaultMultiplierBps;\\n        priceFeed = _priceFeed;\\n\\n        if (_roleAdmin != address(0x0)) {\\n            _grantRole(DEFAULT_ADMIN_ROLE, _roleAdmin); // _roleAdmin can grant and revoke all roles\\n        }\\n\\n        for (uint256 i = 0; i < _messageLibs.length; ++i) {\\n            _grantRole(MESSAGE_LIB_ROLE, _messageLibs[i]);\\n        }\\n\\n        for (uint256 i = 0; i < _admins.length; ++i) {\\n            _grantRole(ADMIN_ROLE, _admins[i]);\\n        }\\n    }\\n\\n    // ========================= Modifier =========================\\n\\n    modifier onlyAcl(address _sender) {\\n        if (!hasAcl(_sender)) {\\n            revert Worker_NotAllowed();\\n        }\\n        _;\\n    }\\n\\n    /// @dev Access control list using allowlist and denylist\\n    /// @dev 1) if one address is in the denylist -> deny\\n    /// @dev 2) else if address in the allowlist OR allowlist is empty (allows everyone)-> allow\\n    /// @dev 3) else deny\\n    /// @param _sender address to check\\n    function hasAcl(address _sender) public view returns (bool) {\\n        if (hasRole(DENYLIST, _sender)) {\\n            return false;\\n        } else if (allowlistSize == 0 || hasRole(ALLOWLIST, _sender)) {\\n            return true;\\n        } else {\\n            return false;\\n        }\\n    }\\n\\n    // ========================= OnyDefaultAdmin =========================\\n\\n    /// @dev flag to pause execution of workers (if used with whenNotPaused modifier)\\n    /// @param _paused true to pause, false to unpause\\n    function setPaused(bool _paused) external onlyRole(DEFAULT_ADMIN_ROLE) {\\n        if (_paused) {\\n            _pause();\\n        } else {\\n            _unpause();\\n        }\\n    }\\n\\n    // ========================= OnlyAdmin =========================\\n\\n    /// @param _priceFeed price feed address\\n    function setPriceFeed(address _priceFeed) external onlyRole(ADMIN_ROLE) {\\n        priceFeed = _priceFeed;\\n        emit SetPriceFeed(_priceFeed);\\n    }\\n\\n    /// @param _workerFeeLib worker fee lib address\\n    function setWorkerFeeLib(address _workerFeeLib) external onlyRole(ADMIN_ROLE) {\\n        workerFeeLib = _workerFeeLib;\\n        emit SetWorkerLib(_workerFeeLib);\\n    }\\n\\n    /// @param _multiplierBps default multiplier for worker fee\\n    function setDefaultMultiplierBps(uint16 _multiplierBps) external onlyRole(ADMIN_ROLE) {\\n        defaultMultiplierBps = _multiplierBps;\\n        emit SetDefaultMultiplierBps(_multiplierBps);\\n    }\\n\\n    /// @dev supports withdrawing fee from ULN301, ULN302 and more\\n    /// @param _lib message lib address\\n    /// @param _to address to withdraw fee to\\n    /// @param _amount amount to withdraw\\n    function withdrawFee(address _lib, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {\\n        if (!hasRole(MESSAGE_LIB_ROLE, _lib)) revert Worker_OnlyMessageLib();\\n        ISendLib(_lib).withdrawFee(_to, _amount);\\n        emit Withdraw(_lib, _to, _amount);\\n    }\\n\\n    /// @dev supports withdrawing token from the contract\\n    /// @param _token token address\\n    /// @param _to address to withdraw token to\\n    /// @param _amount amount to withdraw\\n    function withdrawToken(address _token, address _to, uint256 _amount) external onlyRole(ADMIN_ROLE) {\\n        // transfers native if _token is address(0x0)\\n        Transfer.nativeOrToken(_token, _to, _amount);\\n    }\\n\\n    function setSupportedOptionTypes(uint32 _eid, uint8[] calldata _optionTypes) external onlyRole(ADMIN_ROLE) {\\n        supportedOptionTypes[_eid] = _optionTypes;\\n    }\\n\\n    // ========================= View Functions =========================\\n    function getSupportedOptionTypes(uint32 _eid) external view returns (uint8[] memory) {\\n        return supportedOptionTypes[_eid];\\n    }\\n\\n    // ========================= Internal Functions =========================\\n\\n    /// @dev overrides AccessControl to allow for counting of allowlistSize\\n    /// @param _role role to grant\\n    /// @param _account address to grant role to\\n    function _grantRole(bytes32 _role, address _account) internal override {\\n        if (_role == ALLOWLIST && !hasRole(_role, _account)) {\\n            ++allowlistSize;\\n        }\\n        super._grantRole(_role, _account);\\n    }\\n\\n    /// @dev overrides AccessControl to allow for counting of allowlistSize\\n    /// @param _role role to revoke\\n    /// @param _account address to revoke role from\\n    function _revokeRole(bytes32 _role, address _account) internal override {\\n        if (_role == ALLOWLIST && hasRole(_role, _account)) {\\n            --allowlistSize;\\n        }\\n        super._revokeRole(_role, _account);\\n    }\\n\\n    /// @dev overrides AccessControl to disable renouncing of roles\\n    function renounceRole(bytes32 /*role*/, address /*account*/) public pure override {\\n        revert Worker_RoleRenouncingDisabled();\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[47] private __gap;\\n}\\n\",\"keccak256\":\"0xdef5a8f2212f21a2298a58a2922f5dc9e655bf97a01dd0850481a7fc7ea18924\",\"license\":\"LZBL-1.2\"},\"hardhat-deploy/solc_0.8/proxy/Proxied.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nabstract contract Proxied {\\n    /// @notice to be used by initialisation / postUpgrade function so that only the proxy's admin can execute them\\n    /// It also allows these functions to be called inside a contructor\\n    /// even if the contract is meant to be used without proxy\\n    modifier proxied() {\\n        address proxyAdminAddress = _proxyAdmin();\\n        // With hardhat-deploy proxies\\n        // the proxyAdminAddress is zero only for the implementation contract\\n        // if the implementation contract want to be used as a standalone/immutable contract\\n        // it simply has to execute the `proxied` function\\n        // This ensure the proxyAdminAddress is never zero post deployment\\n        // And allow you to keep the same code for both proxied contract and immutable contract\\n        if (proxyAdminAddress == address(0)) {\\n            // ensure can not be called twice when used outside of proxy : no admin\\n            // solhint-disable-next-line security/no-inline-assembly\\n            assembly {\\n                sstore(\\n                    0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103,\\n                    0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\\n                )\\n            }\\n        } else {\\n            require(msg.sender == proxyAdminAddress);\\n        }\\n        _;\\n    }\\n\\n    modifier onlyProxyAdmin() {\\n        require(msg.sender == _proxyAdmin(), \\\"NOT_AUTHORIZED\\\");\\n        _;\\n    }\\n\\n    function _proxyAdmin() internal view returns (address ownerAddress) {\\n        // solhint-disable-next-line security/no-inline-assembly\\n        assembly {\\n            ownerAddress := sload(0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xaaceeafeeaf0d200ca3942d8bf14c1c4f787a77f79cc87c08bb668e65acdee29\",\"license\":\"MIT\"}},\"version\":1}",
   "bytecode": "0x60a060405234801561001057600080fd5b5060405161183f38038061183f83398101604081905261002f91610099565b61003833610049565b6001600160a01b03166080526100c9565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6000602082840312156100ab57600080fd5b81516001600160a01b03811681146100c257600080fd5b9392505050565b60805161173f61010060003960008181610266015281816102ff015281816104f3015281816105b30152610645015261173f6000f3fe6080604052600436106100d25760003560e01c806366e654181161007f5780638da5cb5b116100595780638da5cb5b1461020057806397a656141461024c578063c34c08e514610254578063f2fde38b1461028857600080fd5b806366e65418146101ab578063715018a6146101cb578063882357e8146101e057600080fd5b80634e4fe306116100b05780634e4fe306146101495780634f49d4711461017657806362a8fdcb1461019657600080fd5b806337ce069c146100d75780633bec591e146100f95780634736d97814610124575b600080fd5b3480156100e357600080fd5b506100f76100f23660046110e0565b6102a8565b005b34801561010557600080fd5b5061010e61036e565b60405161011b91906111b6565b60405180910390f35b34801561013057600080fd5b5061013b6210000081565b60405190815260200161011b565b34801561015557600080fd5b506101696101643660046111d0565b61038b565b60405161011b91906111f2565b34801561018257600080fd5b506100f76101913660046110e0565b6104cd565b3480156101a257600080fd5b5061013b600281565b3480156101b757600080fd5b506100f76101c63660046110e0565b61058d565b3480156101d757600080fd5b506100f7610612565b3480156101ec57600080fd5b506100f76101fb3660046110e0565b610626565b34801561020c57600080fd5b5060005473ffffffffffffffffffffffffffffffffffffffff165b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161011b565b6100f76106d9565b34801561026057600080fd5b506102277f000000000000000000000000000000000000000000000000000000000000000081565b34801561029457600080fd5b506100f76102a3366004611236565b6106e9565b6102b06107a0565b6000806102bd8484610821565b6040517f3146646a000000000000000000000000000000000000000000000000000000008152919350915073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690633146646a90610336908590859060040161126c565b600060405180830381600087803b15801561035057600080fd5b505af1158015610364573d6000803e3d6000fd5b5050505050505050565b606061038661038136600481600061128e565b61088c565b905090565b60608260028110806103a05750621000008110155b156103df576040517f50695b8f000000000000000000000000000000000000000000000000000000008152600481018290526024015b60405180910390fd5b8260028110806103f25750621000008110155b1561042c576040517f50695b8f000000000000000000000000000000000000000000000000000000008152600481018290526024016103d6565b838510156104c55784840367ffffffffffffffff81111561044f5761044f6112b8565b604051908082528060200260200182016040528015610478578160200160208202803683370190505b509250845b848110156104c35760018162100000811061049a5761049a6112e7565b015484878303815181106104b0576104b06112e7565b602090810291909101015260010161047d565b505b505092915050565b6104d56107a0565b60008060008060006104e78787610a29565b945094509450945094507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16633927c07586868686866040518663ffffffff1660e01b8152600401610552959493929190611373565b600060405180830381600087803b15801561056c57600080fd5b505af1158015610580573d6000803e3d6000fd5b5050505050505050505050565b6105956107a0565b60008060008060006105a78787610b84565b945094509450945094507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663475b6d9e86868686866040518663ffffffff1660e01b81526004016105529594939291906113dc565b61061a6107a0565b6106246000610c82565b565b61062e6107a0565b600080600061063d8585610cf7565b9250925092507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16638624ba078484846040518463ffffffff1660e01b81526004016106a093929190611454565b600060405180830381600087803b1580156106ba57600080fd5b505af11580156106ce573d6000803e3d6000fd5b505050505050505050565b6106246106e461036e565b610f6e565b6106f16107a0565b73ffffffffffffffffffffffffffffffffffffffff8116610794576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016103d6565b61079d81610c82565b50565b60005473ffffffffffffffffffffffffffffffffffffffff163314610624576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016103d6565b60606000610832600882858761128e565b61083b9161151e565b60c01c905061084d836008818761128e565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929793965092945050505050565b60405160208101838301845b818110156109f757803560008160fe1c600081146108cd57600181146108e85760028114610943576003811461095757610967565b60018360001a01803688379590950194505050600101610898565b60018360001a601f16017f2000000000000000000000000000000000000000000000000000000000000000841615610927576000875280602003870196505b8060018601883795860195939093016001019250610898915050565b8260041b60f41c9150600284019350610967565b8260041b60ec1c91506003840193505b506000818015610985576001811461098d5782600101549150610991565b339150610991565b3091505b508260021b60fe1c600081146109c257600181146109d057600281146109e1578160081b8752601f870196506109ee565b8187526020870196506109ee565b8160601b87526014870196506109ee565b8160e01b87526004870196505b50505050610898565b50507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe082820301825260405292915050565b6040805160608101825260008082526020820181905291810191909152606060008181610a59600482888a61128e565b610a6291611564565b60e01c9250610a7560086004888a61128e565b610a7e91611564565b60e01c8552610a9160286008888a61128e565b610a9a916115aa565b6020860152610aad60306028888a61128e565b610ab69161151e565b60c01c6040860152610acc60386030888a61128e565b610ad59161151e565b60c01c90506000610aea60406038898b61128e565b610af39161151e565b60c01c90506040888189610b078583611616565b92610b149392919061128e565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929650610b609250505067ffffffffffffffff831682611616565b9050610b76610b718983818d61128e565b610f90565b955050509295509295909350565b6040805160608101825260008082526020820181905291810191909152600080606081610bb4600482888a61128e565b610bbd91611564565b60e01c9050610bd060086004888a61128e565b610bd991611564565b60e01c8552610bec60286008888a61128e565b610bf5916115aa565b6020860152610c0860306028888a61128e565b610c119161151e565b60c01c6040860152610c2760446030888a61128e565b610c3091611629565b60601c92506000610c436004604461166f565b9050610c5560ff82166044898b61128e565b610c5e91611564565b60e01c9450610c75610b718860ff8416818c61128e565b9250509295509295909350565b6000805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6040805160c081018252600080825282516060818101855282825260208083018490528286018490528401919091529282018190528183018390526080820183905260a0820181905290610d4f60046000868861128e565b610d5891611564565b60e01c9150610d6b60086004868861128e565b610d7491611564565b602082015160e09190911c9052610d8f60286008868861128e565b610d98916115aa565b6020808301510152610dae60306028868861128e565b610db79161151e565b602082015160c09190911c604090910152610dd660446030868861128e565b610ddf91611629565b60601c8152610df260646044868861128e565b610dfb916115aa565b6040820152610e0e606c6064868861128e565b610e179161151e565b60c01c60a08201526000610e2f6074606c878961128e565b610e389161151e565b60c01c90506074868187610e4c8583611616565b92610e599392919061128e565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050506060840152610ea667ffffffffffffffff831682611616565b90506000878288610eb8600883611616565b92610ec59392919061128e565b610ece9161151e565b60c01c9050610ede600883611616565b9150878288610ef767ffffffffffffffff851683611616565b92610f049392919061128e565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050506080850152610f5167ffffffffffffffff821683611616565b9150610f62610b718884818c61128e565b95505050509250925092565b600080825160208401305af43d6000803e8015610f8a573d6000f35b503d6000fd5b6060600080610fa0601d85611688565b90508067ffffffffffffffff811115610fbb57610fbb6112b8565b60405190808252806020026020018201604052801561100057816020015b6040805180820190915260008082526020820152815260200190600190039081610fd95790505b50925060005b818110156104c35785838661101c601483611616565b926110299392919061128e565b61103291611629565b60601c848281518110611047576110476112e7565b602090810291909101015173ffffffffffffffffffffffffffffffffffffffff9091169052611077601484611616565b9250858386611087600983611616565b926110949392919061128e565b61109d916116c3565b60b81c68ffffffffffffffffff168482815181106110bd576110bd6112e7565b60209081029190910181015101526110d6600984611616565b9250600101611006565b600080602083850312156110f357600080fd5b823567ffffffffffffffff8082111561110b57600080fd5b818501915085601f83011261111f57600080fd5b81358181111561112e57600080fd5b86602082850101111561114057600080fd5b60209290920196919550909350505050565b6000815180845260005b818110156111785760208185018101518683018201520161115c565b5060006020828601015260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010191505092915050565b6020815260006111c96020830184611152565b9392505050565b600080604083850312156111e357600080fd5b50508035926020909101359150565b6020808252825182820181905260009190848201906040850190845b8181101561122a5783518352928401929184019160010161120e565b50909695505050505050565b60006020828403121561124857600080fd5b813573ffffffffffffffffffffffffffffffffffffffff811681146111c957600080fd5b60408152600061127f6040830185611152565b90508260208301529392505050565b6000808585111561129e57600080fd5b838611156112ab57600080fd5b5050820193919092039150565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60008151808452602080850194506020840160005b83811015611368578151805173ffffffffffffffffffffffffffffffffffffffff168852830151838801526040909601959082019060010161132b565b509495945050505050565b855163ffffffff1681526020808701519082015260408087015167ffffffffffffffff169082015260e0606082015260006113b160e0830187611316565b85608084015282810360a08401526113c98186611152565b9150508260c08301529695505050505050565b855163ffffffff1681526020808701519082015260408087015167ffffffffffffffff169082015263ffffffff8516606082015273ffffffffffffffffffffffffffffffffffffffff8416608082015260e060a0820152600061144260e0830185611316565b90508260c08301529695505050505050565b6060815260006114676060830186611316565b846020840152828103604084015261010073ffffffffffffffffffffffffffffffffffffffff855116825260208501516114c86020840182805163ffffffff1682526020808201519083015260409081015167ffffffffffffffff16910152565b506040850151608083015260608501518160a08401526114ea82840182611152565b915050608085015182820360c08401526115048282611152565b91505060a085015160e08301528092505050949350505050565b7fffffffffffffffff00000000000000000000000000000000000000000000000081358181169160088510156104c55760089490940360031b84901b1690921692915050565b7fffffffff0000000000000000000000000000000000000000000000000000000081358181169160048510156104c55760049490940360031b84901b1690921692915050565b803560208310156115e1577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff602084900360031b1b165b92915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b808201808211156115e1576115e16115e7565b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000081358181169160148510156104c55760149490940360031b84901b1690921692915050565b60ff81811683821601908111156115e1576115e16115e7565b6000826116be577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b7fffffffffffffffffff000000000000000000000000000000000000000000000081358181169160098510156104c55760099490940360031b84901b169092169291505056fea26469706673582212201e6e2b8c660b38a39cb8b1ec607acb2babcc6d7646b55f90241609dfc2e0b64364736f6c63430008160033",
   "deployedBytecode": "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",
@@ -302,7 +302,7 @@
   "storageLayout": {
     "storage": [
       {
-        "astId": 4336,
+        "astId": 7808,
         "contract": "contracts/decompressor/ExecutorDecompressor.sol:ExecutorDecompressor",
         "label": "_owner",
         "offset": 0,
@@ -310,7 +310,7 @@
         "type": "t_address"
       },
       {
-        "astId": 6583,
+        "astId": 17117,
         "contract": "contracts/decompressor/ExecutorDecompressor.sol:ExecutorDecompressor",
         "label": "_dict",
         "offset": 0,