{"matchId":"30665401","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-06-03T18:18:12Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"462:3736:8:-:0;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c5436f06d1e050a95cb7829ce861e76b73c682bf34087a8a82c7942f6559776e64736f6c63430008170033","offset":3323}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"462:3736:8:-:0;;;;;;;;;-1:-1:-1;462:3736:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;2857:49;;;:113;;;;462:3736;2857:163;;;;462:3736;-1:-1:-1;462:3736:8;;;;;;;;;;;2857:163;462:3736;2986:34;;;2857:163;;;:113;462:3736;2922:48;;;-1:-1:-1;2857:113:8;;462:3736;;;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;3309:41;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;462:3736:8;;4038:48;462:3736;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;3659:43;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;899:13;;-1:-1:-1;914:16:8;;;;;;462:3736;932:3;951:27;970:8;;;;;:::i;:::-;951:27;:::i;:::-;462:3736;;;;;;:::i;:::-;;;;:::i;:::-;997:42;462:3736;;1110:102;1142:12;;;;462:3736;;;;1110:102;;;;;;:::i;:::-;462:3736;2200:10;462:3736;1247:38;;462:3736;1247:38;;1279:4;462:3736;1279:4;1247:38;1279:4;;1247:38;;;462:3736;;;;;;;;;;;;1247:38;;462:3736;;1247:38;;;;;;;1648:6;1247:38;-1:-1:-1;1247:38:8;;;993:1133;1230:55;;1388:10;1384:185;;993:1133;1608:13;2212;1608;;;2452:167;2303:322;2452:167;;;;;2303:322;1648:6;-1:-1:-1;2176:11:8;462:3736;2176:11;;;462:3736;;;;;;2200:10;;;2212:13;2200:10;;;462:3736;2212:13;;;2176:50;;;;;;;;;;;;:::i;:::-;2244:8;;2240:40;;932:3;;462:3736;932:3;899:13;462:3736;899:13;;2240:40;462:3736;2261:19;;;462:3736;;;2261:19;;;;;;:::i;:::-;;;;1384:185;462:3736;;;-1:-1:-1;1384:185:8;;;1247:38;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;:::i;993:1133::-;1697:26;462:3736;;;;;:::i;:::-;;;;:::i;:::-;1680:43;1697:26;;1756:21;2200:10;1743;;462:3736;993:1133;;1676:450;1819:28;462:3736;;;;;:::i;:::-;;;;:::i;:::-;1802:45;993:1133;1798:328;1867:51;1883:35;1894:12;1960:13;1894:12;;;462:3736;;;;1883:35;;;;;;:::i;:::-;462:3736;;;;1960:13;2200:10;462:3736;;1960:35;;1984:10;1960:35;;;462:3736;;;;;;1984:10;;462:3736;;;;;;1960:35;462:3736;;;;1960:35;;;;;;462:3736;1960:35;2071:13;1960:35;-1:-1:-1;1960:35:8;;;1798:328;2064:4;;1984:10;;2071:13;;:::i;:::-;2103:8;;1960:35;;;;;;;;;;;;;;;:::i;:::-;;;;;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;462:3736:8;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;-1:-1:-1;462:3736:8;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;462:3736:8;;;;:::o;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;1355:203:3:-;;5535:69:5;1355:203:3;;;;462:3736:8;;1482:68:3;;;;;462:3736:8;1482:68:3;;462:3736:8;;;;;;1482:68:3;;;462:3736:8;;;;;;;;;;;1482:68:3;;;;;:::i;:::-;462:3736:8;;;;;;;:::i;:::-;1482:68:3;462:3736:8;;;1482:68:3;462:3736:8;;;-1:-1:-1;5487:31:5;;;;;;;;;;;;:::i;:::-;5535:69;;:::i;:::-;462:3736:8;;5728:22:3;;;:56;;;;;1355:203;5720:111;;;;;;:::i;5728:56::-;5754:30;;;;1482:68;5754:30;;;462:3736:8;;;;1482:68:3;5754:30;462:3736:8;;;;;;;;;5728:56:3;5720:111;5728:56;;;;;462:3736:8;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;7671:628:5;;;;7875:418;;;462:3736:8;;;7906:22:5;7902:286;;8201:17;;:::o;7902:286::-;1702:19;:23;462:3736:8;;8201:17:5;:::o;462:3736:8:-;;;;;;;;;;;;;;;;;;;;;;;7875:418:5;462:3736:8;;;;-1:-1:-1;8980:21:5;:17;;9152:142;;;;;;;8976:379;462:3736:8;;;;9324:20:5;;;;;;462:3736:8;9324:20:5;;;462:3736:8;;;;;;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c5436f06d1e050a95cb7829ce861e76b73c682bf34087a8a82c7942f6559776e64736f6c63430008170033","offset":3295}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x9821d256ff5aafd97e6809a0be055779f3e8975fd9be02f879708781e4a5b603","blockNumber":"42723028","transactionIndex":"10","deployer":"0xb5e6C16Cb726bb24075075E0993971Aa8D73f764"},"sources":{"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev _Available since v3.1._\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (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 */\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    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"},"@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"},"@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"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@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"},"@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"},"contracts/interfaces/ISquidMulticall.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/// @title SquidMulticall\n/// @notice Multicall logic specific to Squid calls format. The contract specificity is mainly\n/// to enable ERC20 and native token amounts in calldata between two calls.\n/// @dev Support receiption of NFTs.\ninterface ISquidMulticall {\n    /// @notice Call type that enables to specific behaviours of the multicall.\n    enum CallType {\n        // Will simply run calldata\n        Default,\n        // Will update amount field in calldata with ERC20 token balance of the multicall contract.\n        FullTokenBalance,\n        // Will update amount field in calldata with native token balance of the multicall contract.\n        FullNativeBalance,\n        // Will run a safeTransferFrom to get full ERC20 token balance of the caller.\n        CollectTokenBalance\n    }\n\n    /// @notice Calldata format expected by multicall.\n    struct Call {\n        // Call type, see CallType struct description.\n        CallType callType;\n        // Address that will be called.\n        address target;\n        // Native token amount that will be sent in call.\n        uint256 value;\n        // Calldata that will be send in call.\n        bytes callData;\n        // Extra data used by multicall depending on call type.\n        // Default: unused (provide 0x)\n        // FullTokenBalance: address of the ERC20 token to get balance of and zero indexed position\n        // of the amount parameter to update in function call contained by calldata.\n        // Expect format is: abi.encode(address token, uint256 amountParameterPosition)\n        // Eg: for function swap(address tokenIn, uint amountIn, address tokenOut, uint amountOutMin,)\n        // amountParameterPosition would be 1.\n        // FullNativeBalance: unused (provide 0x)\n        // CollectTokenBalance: address of the ERC20 token to collect.\n        // Expect format is: abi.encode(address token)\n        bytes payload;\n    }\n\n    /// Thrown when one of the calls fails.\n    /// @param callPosition Zero indexed position of the call in the call set provided to the\n    /// multicall.\n    /// @param reason Revert data returned by contract called in failing call.\n    error CallFailed(uint256 callPosition, bytes reason);\n\n    /// @notice Main function of the multicall that runs the call set.\n    /// @param calls Call set to be ran by multicall.\n    function run(Call[] calldata calls) external payable;\n}\n"},"contracts/router/SquidMulticall.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {ISquidMulticall} from \"../interfaces/ISquidMulticall.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {IERC721Receiver} from \"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\";\nimport {IERC1155Receiver} from \"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract SquidMulticall is ISquidMulticall, IERC721Receiver, IERC1155Receiver {\n    using SafeERC20 for IERC20;\n\n    bytes4 private constant ERC165_INTERFACE_ID = 0x01ffc9a7;\n    bytes4 private constant ERC721_TOKENRECEIVER_INTERFACE_ID = 0x150b7a02;\n    bytes4 private constant ERC1155_TOKENRECEIVER_INTERFACE_ID = 0x4e2312e0;\n\n    /// @inheritdoc ISquidMulticall\n    function run(Call[] calldata calls) external payable {\n        for (uint256 i = 0; i < calls.length; i++) {\n            Call memory call = calls[i];\n\n            if (call.callType == CallType.FullTokenBalance) {\n                (address token, uint256 amountParameterPosition) = abi.decode(\n                    call.payload,\n                    (address, uint256)\n                );\n                uint256 amount = IERC20(token).balanceOf(address(this));\n                // Deduct 1 from amount to keep hot balances and reduce gas cost\n                if (amount > 0) {\n                    // Cannot underflow because amount > 0\n                    unchecked {\n                        amount -= 1;\n                    }\n                }\n                _setCallDataParameter(call.callData, amountParameterPosition, amount);\n            } else if (call.callType == CallType.FullNativeBalance) {\n                call.value = address(this).balance;\n            } else if (call.callType == CallType.CollectTokenBalance) {\n                address token = abi.decode(call.payload, (address));\n                uint256 senderBalance = IERC20(token).balanceOf(msg.sender);\n                IERC20(token).safeTransferFrom(msg.sender, address(this), senderBalance);\n                continue;\n            }\n\n            (bool success, bytes memory data) = call.target.call{value: call.value}(call.callData);\n            if (!success) revert CallFailed(i, data);\n        }\n    }\n\n    function _setCallDataParameter(\n        bytes memory callData,\n        uint256 parameterPosition,\n        uint256 value\n    ) private pure {\n        assembly {\n            // 36 bytes shift because 32 for prefix + 4 for selector\n            mstore(add(callData, add(36, mul(parameterPosition, 32))), value)\n        }\n    }\n\n    /// @notice Implementation required by ERC165 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-165.\n    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {\n        return\n            interfaceId == ERC1155_TOKENRECEIVER_INTERFACE_ID ||\n            interfaceId == ERC721_TOKENRECEIVER_INTERFACE_ID ||\n            interfaceId == ERC165_INTERFACE_ID;\n    }\n\n    /// @notice Implementation required by ERC721 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-721.\n    function onERC721Received(\n        address,\n        address,\n        uint256,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC721Receiver.onERC721Received.selector;\n    }\n\n    /// @notice Implementation required by ERC1155 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-1155.\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC1155Receiver.onERC1155Received.selector;\n    }\n\n    /// @notice Implementation required by ERC1155 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-1155.\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] calldata,\n        uint256[] calldata,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC1155Receiver.onERC1155BatchReceived.selector;\n    }\n\n    /// @dev Enable native tokens reception with .transfer or .send\n    receive() external payable {}\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.23+commit.f704f362","compilerSettings":{"viaIR":true,"libraries":{},"optimizer":{"runs":99999,"enabled":true},"evmVersion":"paris"},"name":"SquidMulticall","fullyQualifiedName":"contracts/router/SquidMulticall.sol:SquidMulticall"},"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"callPosition","type":"uint256","internalType":"uint256"},{"name":"reason","type":"bytes","internalType":"bytes"}]},{"name":"onERC1155BatchReceived","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"onERC1155Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"onERC721Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"run","type":"function","inputs":[{"name":"calls","type":"tuple[]","components":[{"name":"callType","type":"uint8","internalType":"enum ISquidMulticall.CallType"},{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"payload","type":"bytes","internalType":"bytes"}],"internalType":"struct ISquidMulticall.Call[]"}],"outputs":[],"stateMutability":"payable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"pure"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.23+commit.f704f362"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"callPosition","type":"uint256"},{"internalType":"bytes","name":"reason","type":"bytes"}],"name":"CallFailed","type":"error"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"enum ISquidMulticall.CallType","name":"callType","type":"uint8"},{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct ISquidMulticall.Call[]","name":"calls","type":"tuple[]"}],"name":"run","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"errors":{"CallFailed(uint256,bytes)":[{"params":{"callPosition":"Zero indexed position of the call in the call set provided to the multicall.","reason":"Revert data returned by contract called in failing call."}}]},"kind":"dev","methods":{"run((uint8,address,uint256,bytes,bytes)[])":{"params":{"calls":"Call set to be ran by multicall."}}},"version":1},"userdoc":{"errors":{"CallFailed(uint256,bytes)":[{"notice":"Thrown when one of the calls fails."}]},"kind":"user","methods":{"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."},"onERC1155Received(address,address,uint256,uint256,bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."},"onERC721Received(address,address,uint256,bytes)":{"notice":"Implementation required by ERC721 for NFT reception. See https://eips.ethereum.org/EIPS/eip-721."},"run((uint8,address,uint256,bytes,bytes)[])":{"notice":"Main function of the multicall that runs the call set."},"supportsInterface(bytes4)":{"notice":"Implementation required by ERC165 for NFT reception. See https://eips.ethereum.org/EIPS/eip-165."}},"version":1}},"settings":{"compilationTarget":{"contracts/router/SquidMulticall.sol":"SquidMulticall"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":99999},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol":{"keccak256":"0xeb373f1fdc7b755c6a750123a9b9e3a8a02c1470042fd6505d875000a80bde0b","license":"MIT","urls":["bzz-raw://0e28648f994abf1d6bc345644a361cc0b7efa544f8bc0c8ec26011fed85a91ec","dweb:/ipfs/QmVVE7AiRjKaQYYji7TkjmTeVzGpNmms5eoxqTCfvvpj6D"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0xec63854014a5b4f2b3290ab9103a21bdf902a508d0f41a8573fea49e98bf571a","license":"MIT","urls":["bzz-raw://bc5b5dc12fbc4002f282eaa7a5f06d8310ed62c1c77c5770f6283e058454c39a","dweb:/ipfs/Qme9rE2wS3yBuyJq9GgbmzbsBQsW2M2sVFqYYLw7bosGrv"]},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1","license":"MIT","urls":["bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68","dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS"]},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"keccak256":"0xa82b58eca1ee256be466e536706850163d2ec7821945abd6b4778cfb3bee37da","license":"MIT","urls":["bzz-raw://6e75cf83beb757b8855791088546b8337e9d4684e169400c20d44a515353b708","dweb:/ipfs/QmYvPafLfoquiDMEj7CKHtvbgHu7TJNPSVPSCjrtjV8HjV"]},"@openzeppelin/contracts/utils/Address.sol":{"keccak256":"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa","license":"MIT","urls":["bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931","dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1","license":"MIT","urls":["bzz-raw://be161e54f24e5c6fae81a12db1a8ae87bc5ae1b0ddc805d82a1440a68455088f","dweb:/ipfs/QmP7C3CHdY9urF4dEMb9wmsp1wMxHF6nhA2yQE5SKiPAdy"]},"contracts/interfaces/ISquidMulticall.sol":{"keccak256":"0xd4f6492555c266fa8db32a91366a66fe92ab2e7626a01ac3dcf7d23f3b2ee253","license":"MIT","urls":["bzz-raw://2147e5bdf024d62d37f471be5cb15a92453041d7fab7ac4926f96debc5d528b5","dweb:/ipfs/QmWqYu55cVoVK7tS6h91GCkFuD6W7bwAYMHVVzyBASEX1n"]},"contracts/router/SquidMulticall.sol":{"keccak256":"0x4db78dd290b19b6a1a92d12dca82945e9db2bc740634ffa7826b69e1e79a68ea","license":"MIT","urls":["bzz-raw://494774671321a4ca6283b1d86d2e92db592b61a81668100b7728cfcfdac8d0f5","dweb:/ipfs/Qmd6szUZ7VBLZ5pCEiPx4qB9wtfDdLAA37h3EymozfzWXv"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"CallFailed(uint256,bytes)":[{"notice":"Thrown when one of the calls fails."}]},"methods":{"supportsInterface(bytes4)":{"notice":"Implementation required by ERC165 for NFT reception. See https://eips.ethereum.org/EIPS/eip-165."},"run((uint8,address,uint256,bytes,bytes)[])":{"notice":"Main function of the multicall that runs the call set."},"onERC721Received(address,address,uint256,bytes)":{"notice":"Implementation required by ERC721 for NFT reception. See https://eips.ethereum.org/EIPS/eip-721."},"onERC1155Received(address,address,uint256,uint256,bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."},"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."}},"version":1},"devdoc":{"kind":"dev","errors":{"CallFailed(uint256,bytes)":[{"params":{"reason":"Revert data returned by contract called in failing call.","callPosition":"Zero indexed position of the call in the call set provided to the multicall."}}]},"methods":{"run((uint8,address,uint256,bytes,bytes)[])":{"params":{"calls":"Call set to be ran by multicall."}}},"version":1},"sourceIds":{"contracts/router/SquidMulticall.sol":{"id":8},"contracts/interfaces/ISquidMulticall.sol":{"id":7},"@openzeppelin/contracts/utils/Address.sol":{"id":5},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":3},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":6},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/router/SquidMulticall.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {ISquidMulticall} from \"../interfaces/ISquidMulticall.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {IERC721Receiver} from \"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\";\nimport {IERC1155Receiver} from \"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n\ncontract SquidMulticall is ISquidMulticall, IERC721Receiver, IERC1155Receiver {\n    using SafeERC20 for IERC20;\n\n    bytes4 private constant ERC165_INTERFACE_ID = 0x01ffc9a7;\n    bytes4 private constant ERC721_TOKENRECEIVER_INTERFACE_ID = 0x150b7a02;\n    bytes4 private constant ERC1155_TOKENRECEIVER_INTERFACE_ID = 0x4e2312e0;\n\n    /// @inheritdoc ISquidMulticall\n    function run(Call[] calldata calls) external payable {\n        for (uint256 i = 0; i < calls.length; i++) {\n            Call memory call = calls[i];\n\n            if (call.callType == CallType.FullTokenBalance) {\n                (address token, uint256 amountParameterPosition) = abi.decode(\n                    call.payload,\n                    (address, uint256)\n                );\n                uint256 amount = IERC20(token).balanceOf(address(this));\n                // Deduct 1 from amount to keep hot balances and reduce gas cost\n                if (amount > 0) {\n                    // Cannot underflow because amount > 0\n                    unchecked {\n                        amount -= 1;\n                    }\n                }\n                _setCallDataParameter(call.callData, amountParameterPosition, amount);\n            } else if (call.callType == CallType.FullNativeBalance) {\n                call.value = address(this).balance;\n            } else if (call.callType == CallType.CollectTokenBalance) {\n                address token = abi.decode(call.payload, (address));\n                uint256 senderBalance = IERC20(token).balanceOf(msg.sender);\n                IERC20(token).safeTransferFrom(msg.sender, address(this), senderBalance);\n                continue;\n            }\n\n            (bool success, bytes memory data) = call.target.call{value: call.value}(call.callData);\n            if (!success) revert CallFailed(i, data);\n        }\n    }\n\n    function _setCallDataParameter(\n        bytes memory callData,\n        uint256 parameterPosition,\n        uint256 value\n    ) private pure {\n        assembly {\n            // 36 bytes shift because 32 for prefix + 4 for selector\n            mstore(add(callData, add(36, mul(parameterPosition, 32))), value)\n        }\n    }\n\n    /// @notice Implementation required by ERC165 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-165.\n    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {\n        return\n            interfaceId == ERC1155_TOKENRECEIVER_INTERFACE_ID ||\n            interfaceId == ERC721_TOKENRECEIVER_INTERFACE_ID ||\n            interfaceId == ERC165_INTERFACE_ID;\n    }\n\n    /// @notice Implementation required by ERC721 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-721.\n    function onERC721Received(\n        address,\n        address,\n        uint256,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC721Receiver.onERC721Received.selector;\n    }\n\n    /// @notice Implementation required by ERC1155 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-1155.\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC1155Receiver.onERC1155Received.selector;\n    }\n\n    /// @notice Implementation required by ERC1155 for NFT reception.\n    /// See https://eips.ethereum.org/EIPS/eip-1155.\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] calldata,\n        uint256[] calldata,\n        bytes calldata\n    ) external pure returns (bytes4) {\n        return IERC1155Receiver.onERC1155BatchReceived.selector;\n    }\n\n    /// @dev Enable native tokens reception with .transfer or .send\n    receive() external payable {}\n}\n"},"contracts/interfaces/ISquidMulticall.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/// @title SquidMulticall\n/// @notice Multicall logic specific to Squid calls format. The contract specificity is mainly\n/// to enable ERC20 and native token amounts in calldata between two calls.\n/// @dev Support receiption of NFTs.\ninterface ISquidMulticall {\n    /// @notice Call type that enables to specific behaviours of the multicall.\n    enum CallType {\n        // Will simply run calldata\n        Default,\n        // Will update amount field in calldata with ERC20 token balance of the multicall contract.\n        FullTokenBalance,\n        // Will update amount field in calldata with native token balance of the multicall contract.\n        FullNativeBalance,\n        // Will run a safeTransferFrom to get full ERC20 token balance of the caller.\n        CollectTokenBalance\n    }\n\n    /// @notice Calldata format expected by multicall.\n    struct Call {\n        // Call type, see CallType struct description.\n        CallType callType;\n        // Address that will be called.\n        address target;\n        // Native token amount that will be sent in call.\n        uint256 value;\n        // Calldata that will be send in call.\n        bytes callData;\n        // Extra data used by multicall depending on call type.\n        // Default: unused (provide 0x)\n        // FullTokenBalance: address of the ERC20 token to get balance of and zero indexed position\n        // of the amount parameter to update in function call contained by calldata.\n        // Expect format is: abi.encode(address token, uint256 amountParameterPosition)\n        // Eg: for function swap(address tokenIn, uint amountIn, address tokenOut, uint amountOutMin,)\n        // amountParameterPosition would be 1.\n        // FullNativeBalance: unused (provide 0x)\n        // CollectTokenBalance: address of the ERC20 token to collect.\n        // Expect format is: abi.encode(address token)\n        bytes payload;\n    }\n\n    /// Thrown when one of the calls fails.\n    /// @param callPosition Zero indexed position of the call in the call set provided to the\n    /// multicall.\n    /// @param reason Revert data returned by contract called in failing call.\n    error CallFailed(uint256 callPosition, bytes reason);\n\n    /// @notice Main function of the multicall that runs the call set.\n    /// @param calls Call set to be ran by multicall.\n    function run(Call[] calldata calls) external payable;\n}\n"},"@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"},"@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"},"@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"},"@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"},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev _Available since v3.1._\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (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 */\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    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"}},"language":"Solidity","settings":{"viaIR":true,"libraries":{},"optimizer":{"runs":99999,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/router/SquidMulticall.sol":{"id":8},"contracts/interfaces/ISquidMulticall.sol":{"id":7},"@openzeppelin/contracts/utils/Address.sol":{"id":5},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":3},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":6},"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":2}},"contracts":{"contracts/router/SquidMulticall.sol":{"SquidMulticall":{"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"callPosition","type":"uint256","internalType":"uint256"},{"name":"reason","type":"bytes","internalType":"bytes"}]},{"name":"onERC1155BatchReceived","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"onERC1155Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"onERC721Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"pure"},{"name":"run","type":"function","inputs":[{"name":"calls","type":"tuple[]","components":[{"name":"callType","type":"uint8","internalType":"enum ISquidMulticall.CallType"},{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"payload","type":"bytes","internalType":"bytes"}],"internalType":"struct ISquidMulticall.Call[]"}],"outputs":[],"stateMutability":"payable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"pure"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.23+commit.f704f362\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"callPosition\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"reason\",\"type\":\"bytes\"}],\"name\":\"CallFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC721Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"enum ISquidMulticall.CallType\",\"name\":\"callType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"internalType\":\"struct ISquidMulticall.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"run\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"CallFailed(uint256,bytes)\":[{\"params\":{\"callPosition\":\"Zero indexed position of the call in the call set provided to the multicall.\",\"reason\":\"Revert data returned by contract called in failing call.\"}}]},\"kind\":\"dev\",\"methods\":{\"run((uint8,address,uint256,bytes,bytes)[])\":{\"params\":{\"calls\":\"Call set to be ran by multicall.\"}}},\"version\":1},\"userdoc\":{\"errors\":{\"CallFailed(uint256,bytes)\":[{\"notice\":\"Thrown when one of the calls fails.\"}]},\"kind\":\"user\",\"methods\":{\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\":{\"notice\":\"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155.\"},\"onERC1155Received(address,address,uint256,uint256,bytes)\":{\"notice\":\"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155.\"},\"onERC721Received(address,address,uint256,bytes)\":{\"notice\":\"Implementation required by ERC721 for NFT reception. See https://eips.ethereum.org/EIPS/eip-721.\"},\"run((uint8,address,uint256,bytes,bytes)[])\":{\"notice\":\"Main function of the multicall that runs the call set.\"},\"supportsInterface(bytes4)\":{\"notice\":\"Implementation required by ERC165 for NFT reception. See https://eips.ethereum.org/EIPS/eip-165.\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/router/SquidMulticall.sol\":\"SquidMulticall\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":99999},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\":{\"keccak256\":\"0xeb373f1fdc7b755c6a750123a9b9e3a8a02c1470042fd6505d875000a80bde0b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0e28648f994abf1d6bc345644a361cc0b7efa544f8bc0c8ec26011fed85a91ec\",\"dweb:/ipfs/QmVVE7AiRjKaQYYji7TkjmTeVzGpNmms5eoxqTCfvvpj6D\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0xec63854014a5b4f2b3290ab9103a21bdf902a508d0f41a8573fea49e98bf571a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bc5b5dc12fbc4002f282eaa7a5f06d8310ed62c1c77c5770f6283e058454c39a\",\"dweb:/ipfs/Qme9rE2wS3yBuyJq9GgbmzbsBQsW2M2sVFqYYLw7bosGrv\"]},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68\",\"dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS\"]},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"keccak256\":\"0xa82b58eca1ee256be466e536706850163d2ec7821945abd6b4778cfb3bee37da\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6e75cf83beb757b8855791088546b8337e9d4684e169400c20d44a515353b708\",\"dweb:/ipfs/QmYvPafLfoquiDMEj7CKHtvbgHu7TJNPSVPSCjrtjV8HjV\"]},\"@openzeppelin/contracts/utils/Address.sol\":{\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931\",\"dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://be161e54f24e5c6fae81a12db1a8ae87bc5ae1b0ddc805d82a1440a68455088f\",\"dweb:/ipfs/QmP7C3CHdY9urF4dEMb9wmsp1wMxHF6nhA2yQE5SKiPAdy\"]},\"contracts/interfaces/ISquidMulticall.sol\":{\"keccak256\":\"0xd4f6492555c266fa8db32a91366a66fe92ab2e7626a01ac3dcf7d23f3b2ee253\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2147e5bdf024d62d37f471be5cb15a92453041d7fab7ac4926f96debc5d528b5\",\"dweb:/ipfs/QmWqYu55cVoVK7tS6h91GCkFuD6W7bwAYMHVVzyBASEX1n\"]},\"contracts/router/SquidMulticall.sol\":{\"keccak256\":\"0x4db78dd290b19b6a1a92d12dca82945e9db2bc740634ffa7826b69e1e79a68ea\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://494774671321a4ca6283b1d86d2e92db592b61a81668100b7728cfcfdac8d0f5\",\"dweb:/ipfs/Qmd6szUZ7VBLZ5pCEiPx4qB9wtfDdLAA37h3EymozfzWXv\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"CallFailed(uint256,bytes)":[{"notice":"Thrown when one of the calls fails."}]},"methods":{"supportsInterface(bytes4)":{"notice":"Implementation required by ERC165 for NFT reception. See https://eips.ethereum.org/EIPS/eip-165."},"run((uint8,address,uint256,bytes,bytes)[])":{"notice":"Main function of the multicall that runs the call set."},"onERC721Received(address,address,uint256,bytes)":{"notice":"Implementation required by ERC721 for NFT reception. See https://eips.ethereum.org/EIPS/eip-721."},"onERC1155Received(address,address,uint256,uint256,bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."},"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)":{"notice":"Implementation required by ERC1155 for NFT reception. See https://eips.ethereum.org/EIPS/eip-1155."}},"version":1},"devdoc":{"kind":"dev","errors":{"CallFailed(uint256,bytes)":[{"params":{"reason":"Revert data returned by contract called in failing call.","callPosition":"Zero indexed position of the call in the call set provided to the multicall."}}]},"methods":{"run((uint8,address,uint256,bytes,bytes)[])":{"params":{"calls":"Call set to be ran by multicall."}}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"462:3736:8:-:0;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"462:3736:8:-:0;;;;;;;;;-1:-1:-1;462:3736:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;2857:49;;;:113;;;;462:3736;2857:163;;;;462:3736;-1:-1:-1;462:3736:8;;;;;;;;;;;2857:163;462:3736;2986:34;;;2857:163;;;:113;462:3736;2922:48;;;-1:-1:-1;2857:113:8;;462:3736;;;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;3309:41;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;462:3736:8;;4038:48;462:3736;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;3659:43;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;899:13;;-1:-1:-1;914:16:8;;;;;;462:3736;932:3;951:27;970:8;;;;;:::i;:::-;951:27;:::i;:::-;462:3736;;;;;;:::i;:::-;;;;:::i;:::-;997:42;462:3736;;1110:102;1142:12;;;;462:3736;;;;1110:102;;;;;;:::i;:::-;462:3736;2200:10;462:3736;1247:38;;462:3736;1247:38;;1279:4;462:3736;1279:4;1247:38;1279:4;;1247:38;;;462:3736;;;;;;;;;;;;1247:38;;462:3736;;1247:38;;;;;;;1648:6;1247:38;-1:-1:-1;1247:38:8;;;993:1133;1230:55;;1388:10;1384:185;;993:1133;1608:13;2212;1608;;;2452:167;2303:322;2452:167;;;;;2303:322;1648:6;-1:-1:-1;2176:11:8;462:3736;2176:11;;;462:3736;;;;;;2200:10;;;2212:13;2200:10;;;462:3736;2212:13;;;2176:50;;;;;;;;;;;;:::i;:::-;2244:8;;2240:40;;932:3;;462:3736;932:3;899:13;462:3736;899:13;;2240:40;462:3736;2261:19;;;462:3736;;;2261:19;;;;;;:::i;:::-;;;;1384:185;462:3736;;;-1:-1:-1;1384:185:8;;;1247:38;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;:::i;993:1133::-;1697:26;462:3736;;;;;:::i;:::-;;;;:::i;:::-;1680:43;1697:26;;1756:21;2200:10;1743;;462:3736;993:1133;;1676:450;1819:28;462:3736;;;;;:::i;:::-;;;;:::i;:::-;1802:45;993:1133;1798:328;1867:51;1883:35;1894:12;1960:13;1894:12;;;462:3736;;;;1883:35;;;;;;:::i;:::-;462:3736;;;;1960:13;2200:10;462:3736;;1960:35;;1984:10;1960:35;;;462:3736;;;;;;1984:10;;462:3736;;;;;;1960:35;462:3736;;;;1960:35;;;;;;462:3736;1960:35;2071:13;1960:35;-1:-1:-1;1960:35:8;;;1798:328;2064:4;;1984:10;;2071:13;;:::i;:::-;2103:8;;1960:35;;;;;;;;;;;;;;;:::i;:::-;;;;;462:3736;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;462:3736:8;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;-1:-1:-1;462:3736:8;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;462:3736:8;;;;:::o;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;1355:203:3:-;;5535:69:5;1355:203:3;;;;462:3736:8;;1482:68:3;;;;;462:3736:8;1482:68:3;;462:3736:8;;;;;;1482:68:3;;;462:3736:8;;;;;;;;;;;1482:68:3;;;;;:::i;:::-;462:3736:8;;;;;;;:::i;:::-;1482:68:3;462:3736:8;;;1482:68:3;462:3736:8;;;-1:-1:-1;5487:31:5;;;;;;;;;;;;:::i;:::-;5535:69;;:::i;:::-;462:3736:8;;5728:22:3;;;:56;;;;;1355:203;5720:111;;;;;;:::i;5728:56::-;5754:30;;;;1482:68;5754:30;;;462:3736:8;;;;1482:68:3;5754:30;462:3736:8;;;;;;;;;5728:56:3;5720:111;5728:56;;;;;462:3736:8;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;7671:628:5;;;;7875:418;;;462:3736:8;;;7906:22:5;7902:286;;8201:17;;:::o;7902:286::-;1702:19;:23;462:3736:8;;8201:17:5;:::o;462:3736:8:-;;;;;;;;;;;;;;;;;;;;;;;7875:418:5;462:3736:8;;;;-1:-1:-1;8980:21:5;:17;;9152:142;;;;;;;8976:379;462:3736:8;;;;9324:20:5;;;;;;462:3736:8;9324:20:5;;;462:3736:8;;;;;;:::i","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)","signatureHash4":"0xbc197c81","signatureHash32":"0xbc197c819b3e337a6f9652dd10becd7eef83032af3b9d958d3d42f6694146621"},{"signature":"onERC1155Received(address,address,uint256,uint256,bytes)","signatureHash4":"0xf23a6e61","signatureHash32":"0xf23a6e612e1ff4830e658fe43f4e3cb4a5f8170bd5d9e69fb5d7a7fa9e4fdf97"},{"signature":"onERC721Received(address,address,uint256,bytes)","signatureHash4":"0x150b7a02","signatureHash32":"0x150b7a023d4804d13e8c85fb27262cb750cf6ba9f9dd3bb30d90f482ceeb4b1f"},{"signature":"run((uint8,address,uint256,bytes,bytes)[])","signatureHash4":"0xf87ef800","signatureHash32":"0xf87ef80061ed50a7473d4f400b12ab8ec8f3d993149de7a27ee2af6be109e2fb"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"}],"event":[],"error":[{"signature":"CallFailed(uint256,bytes)","signatureHash4":"0x5c0dee5d","signatureHash32":"0x5c0dee5d32a1e145396705da49c1e64a2b1d63387f78c2697100f655567f5de9"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0xaD6Cea45f98444a922a2b4fE96b8C90F0862D2F4"}