{"matchId":"28517569","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-04T13:07:25Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1535:7377:10:-:0;;;;;;;6007:13:1;1535:7377:10;;;;;;;;;;;;;;6078:31:1;6074:139;;-1:-1:-1;1535:7377:10;;;;;;;;;6074:139:1;1535:7377:10;;;;;;6007:13:1;1535:7377:10;6174:28:1;1535:7377:10;;;;;;6174:28:1;6074:139;;;1535:7377:10;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122025fb7b9bfd54b9b4544f97f93c8042c8a516f3379abe2bd3930f354f2736c62664736f6c63430008180033","offset":3817}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1535:7377:10:-:0;;;;;;;;;;;-1:-1:-1;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;;;2415:73:0;2517:8;1324:62;;;:::i;:::-;2423:22;;2415:73;:::i;:::-;2517:8;:::i;:::-;1535:7377:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;;3301:14:1;3347:34;;;;;;1535:7377:10;3346:108:1;;;;1535:7377:10;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;3562:65:1;;1535:7377:10;-1:-1:-1;;;;;;1535:7377:10;;;3786:77;3794:26;;;3786:77;:::i;:::-;5366:69:1;1535:7377:10;;;;;;5366:69:1;;;:::i;:::-;;:::i;:::-;1216:12:0;965:10:7;1216:12:0;:::i;:::-;5366:69:1;1535:7377:10;;;;;;5366:69:1;;;:::i;:::-;1260:15:2;1535:7377:10;;1260:15:2;1535:7377:10;965:10:7;3932:28:10;3928:91;;1535:7377;;;4029:24;1535:7377;;;4063:26;1535:7377;3647:99:1;;1535:7377:10;;;3647:99:1;1535:7377:10;3721:14:1;1535:7377:10;;;;;;;;;;;;3721:14:1;1535:7377:10;;3928:91;3995:12;;;:::i;:::-;3928:91;;;3562:65:1;-1:-1:-1;;1535:7377:10;;;;;3562:65:1;;;1535:7377:10;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;3346:108:1;3426:4;;1713:19:6;:23;3387:66:1;;3346:108;3387:66;1535:7377:10;;;;;3436:17:1;3346:108;;3347:34;1535:7377:10;;;;;3365:16:1;3347:34;;1535:7377:10;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;4356:24;1535:7377;;;;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;1534:6:0;1535:7377:10;;;-1:-1:-1;;;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;2538:20:2;1324:62:0;;;:::i;:::-;1468:72:2;;:::i;:::-;2519:4;1535:7377:10;;2509:14:2;1535:7377:10;;;2509:14:2;1535:7377:10;;965:10:7;1535:7377:10;;2538:20:2;1535:7377:10;;;;;;;;;;;;;;;1324:62:0;;:::i;:::-;2779:6;1535:7377:10;;-1:-1:-1;;;;;;1535:7377:10;;;;;;;-1:-1:-1;;;;;1535:7377:10;2827:40:0;1535:7377:10;;2827:40:0;1535:7377:10;;;;;;;;;;;;;;;;;;;1949:7:2;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;1861:26;1535:7377;;;;;;;;;;;;;;;;;;;;;;1324:62:0;;:::i;:::-;1949:7:2;1535:7377:10;;;;;;;;-1:-1:-1;;;1535:7377:10;1949:7:2;1535:7377:10;;965:10:7;1535:7377:10;;2785:22:2;;1535:7377:10;;2785:22:2;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;1953:27;1535:7377;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;1468:72:2;;;;;:::i;:::-;8552:12:10;1535:7377;8534:15;:30;8530:122;;4356:24;;1535:7377;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;8789:104;;1535:7377;;;;;7196:48;;;;1535:7377;;;;5471:10;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7196:48;;;;;:::i;:::-;1535:7377;7186:59;;1535:7377;7312:11;1535:7377;2454:27:8;2496:13;;2491:116;2511:16;;;;;;1546:41;;;;7256:156:10;;1535:7377;1228:1:9;1535:7377:10;;;4356:13;1535:7377;;;;;;;1260:12:9;;1535:7377:10;;;1283:28:9;1535:7377:10;;8121:19;;8117:306;1535:7377;;;5471:10;;;;;;8174:32;;;;:::i;:::-;;8224:8;8220:107;;8117:306;;1535:7377;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;;;;;5471:10;1535:7377;;;;;;;;;;;7510:39;1535:7377;;8220:107;1535:7377;;-1:-1:-1;;;8259:53:10;;;8117:306;5546:69:6;1535:7377:10;;1116:58:5;;;;;1535:7377:10;;;1116:58:5;;5471:10:10;1535:7377;1116:58:5;;1535:7377:10;;;;;;;1116:58:5;;;;;:::i;:::-;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;5498:31:6;;;;;;;;:::i;:::-;5546:69;;;:::i;:::-;1535:7377:10;;5871:22:5;;;:56;;;;;8117:306:10;1535:7377;;;;;;;8117:306;;1535:7377;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;;1535:7377;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;5871:56:5;5897:30;;;;;;1535:7377:10;;;;5897:30:5;;1535:7377:10;;;;;;;;5871:56:5;;;;;1535:7377:10;;;;7256:156;1535:7377;;-1:-1:-1;;;7353:48:10;;;2529:3:8;1535:7377:10;;;;;;;;;9305:51:8;:5;;;:51;:5;;;9505:119;;;;1535:7377:10;9505:119:8;;;9305:51;2529:3;1535:7377:10;2496:13:8;;;;9305:51;9505:119;;;;;1535:7377:10;9505:119:8;;;9305:51;;8789:104:10;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8832:50:10;;;8530:122;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8587:54:10;;;1535:7377;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;1468:72:2;;;;;:::i;:::-;8552:12:10;1535:7377;8534:15;:30;8530:122;;4356:24;;1535:7377;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;8789:104;;1535:7377;;;;7196:48;;;;;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7196:48;;;;;:::i;:::-;1535:7377;7186:59;;1535:7377;7312:11;1535:7377;2454:27:8;2496:13;;;2511:16;;;;;;1546:41;;;;;;7256:156:10;;1535:7377;;;1228:1:9;1535:7377:10;;;4356:13;1535:7377;;;;;;;1260:12:9;;1535:7377:10;;;1283:28:9;1535:7377:10;;8121:19;;;8117:306;1535:7377;;;8174:32;;;;;;;;;;:::i;:::-;;8224:8;8220:107;;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;8117:306;;;1535:7377;;;;;;;;;;;;;;;7510:39;1535:7377;;8220:107;1535:7377;;-1:-1:-1;;;8259:53:10;;;8117:306;1535:7377;;;5546:69:6;1535:7377:10;;1116:58:5;;;;;1535:7377:10;;;1116:58:5;;;1535:7377:10;1116:58:5;;1535:7377:10;;;;;;;1116:58:5;;;;;:::i;:::-;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;5498:31:6;;;;;;;;:::i;:::-;5546:69;;;:::i;:::-;1535:7377:10;;5871:22:5;;;:56;;;;;8117:306:10;1535:7377;;;;;;;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;8117:306;;;;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;5871:56:5;5897:30;;;;;;1535:7377:10;;;;5897:30:5;;1535:7377:10;;;;;;;;5871:56:5;;;;;1535:7377:10;;;;7256:156;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;7353:48:10;;;2529:3:8;1535:7377:10;;;;;;;;;;;9305:51:8;:5;;;:51;:5;;;9505:119;;;;;9305:51;2529:3;1535:7377:10;2496:13:8;;;;;;9305:51;9505:119;;;;;;9305:51;;8789:104:10;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8832:50:10;;;8530:122;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8587:54:10;;;1535:7377;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;2031:106:2;1535:7377:10;1949:7:2;1535:7377:10;;;;2031:106:2:o;1535:7377:10:-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;1620:130:0:-;1534:6;1535:7377:10;-1:-1:-1;;;;;1535:7377:10;965:10:7;1683:23:0;1535:7377:10;;1620:130:0:o;1535:7377:10:-;;;;;;;;;;;;;;;;;;;;;;;;;2687:187:0;2779:6;1535:7377:10;;-1:-1:-1;;;;;1535:7377:10;;;-1:-1:-1;;;;;;1535:7377:10;;;;;;;;;;2827:40:0;-1:-1:-1;;2827:40:0;2687:187::o;1535:7377:10:-;;;;:::o;:::-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1535:7377:10;;;;:::o;:::-;;;:::o;7682:628:6:-;;;;7886:418;;;1535:7377:10;;;7917:22:6;7913:286;;8212:17;;:::o;7913:286::-;1713:19;:23;1535:7377:10;;8212:17:6;:::o;1535:7377:10:-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;7886:418:6;1535:7377:10;;;;-1:-1:-1;8991:21:6;:17;;9163:142;;;;;;;8987:379;1535:7377:10;;;;;;9335:20:6;;1535:7377:10;;;9335:20:6;;;1535:7377:10;;;;;;;;;9011:1:6;1535:7377:10;;;;;;;;;;;;9011:1:6;1535:7377:10;;;;;;;;;;;;;;9335:20:6;;;;1535:7377:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;1535:7377:10;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122025fb7b9bfd54b9b4544f97f93c8042c8a516f3379abe2bd3930f354f2736c62664736f6c63430008180033","offset":3618}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x6f3b70013b5beb0b8f002df8a551ecf5b98a25f0213e07e743014d95405cda2d","blockNumber":"25021821","transactionIndex":"293","deployer":"0xF378708B88841Abb63e2316E4Fc8f29469beE885"},"sources":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.24;\n\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport {OwnableUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport {PausableUpgradeable} from \"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\";\nimport {BitMapsUpgradeable} from \"@openzeppelin/contracts-upgradeable/utils/structs/BitMapsUpgradeable.sol\";\nimport {\n    MerkleProofUpgradeable\n} from \"@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol\";\nimport {IERC20Upgradeable} from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport {SafeERC20Upgradeable} from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\n\n/// @title ZkSyncLiteSunsetClaimDistributorL1\n/// @author Matter Labs\n/// @custom:security-contact security@matterlabs.dev\n/// @notice L1 distributor for the ZKsync Lite sunset. Funds committed in a\n/// Merkle tree can be claimed either by the claimant themselves or by any caller\n/// on behalf of the claimant; in both cases the funds are transferred to the\n/// claimant encoded in the leaf.\n/// @dev Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`.\n/// `token == address(0)` denotes a native ETH claim. Leaf indices must be globally\n/// unique across all leaves because the claimed bitmap is keyed only by `index`.\n/// @dev Expected to be deployed as a TransparentUpgradeableProxy.\ncontract ZkSyncLiteSunsetClaimDistributorL1 is Initializable, OwnableUpgradeable, PausableUpgradeable {\n    using BitMapsUpgradeable for BitMapsUpgradeable.BitMap;\n    using SafeERC20Upgradeable for IERC20Upgradeable;\n\n    /// @notice Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`.\n    bytes32 public MERKLE_ROOT;\n    /// @notice Claims are enabled at/after this timestamp.\n    uint256 public WINDOW_START;\n    /// @notice Packed bitmap tracking completion of claims per leaf index.\n    BitMapsUpgradeable.BitMap internal claimedBitMap;\n\n    /// @notice Emitted whenever a call to claim succeeds.\n    /// @param index The index of the claim leaf that was consumed.\n    /// @param claimant The address encoded in the leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount transferred to the claimant.\n    event Claimed(uint256 index, address claimant, address token, uint256 amount);\n\n    /// @notice Thrown when the claim index has already been consumed.\n    error ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed();\n    /// @notice Thrown when the claim window is not yet open.\n    error ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen();\n    /// @notice Thrown when the Merkle proof does not verify against `MERKLE_ROOT`.\n    error ZkSyncLiteSunsetClaimDistributor__InvalidProof();\n    /// @notice Thrown when the native-token transfer to the claimant reverts.\n    error ZkSyncLiteSunsetClaimDistributor__EthTransferFailed();\n\n    /// @notice Disables initializers on the implementation so it can only be used behind a proxy.\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n    /// @notice Initializes proxy storage.\n    /// @param merkleRoot Merkle root for the claim dataset.\n    /// @param windowStart Claim start timestamp (inclusive).\n    /// @param initialOwner Owner allowed to pause and unpause claiming.\n    /// @dev Transfers ownership to `initialOwner` if different from the proxy deployer\n    /// that invokes this initializer.\n    function initialize(bytes32 merkleRoot, uint256 windowStart, address initialOwner) external initializer {\n        require(initialOwner != address(0), \"Ownable: new owner is the zero address\");\n\n        __Ownable_init();\n        __Pausable_init();\n\n        if (initialOwner != _msgSender()) {\n            _transferOwnership(initialOwner);\n        }\n\n        MERKLE_ROOT = merkleRoot;\n        WINDOW_START = windowStart;\n    }\n\n    /// @notice Returns whether a claim index has already been consumed.\n    /// @param index The index of the claim leaf.\n    /// @return Whether the claim has been executed.\n    function isClaimed(uint256 index) public view returns (bool) {\n        return claimedBitMap.get(index);\n    }\n\n    /// @notice Pauses all claim entrypoints.\n    /// @dev Only the owner may pause; halts every claim path until `unpause` is called.\n    function pause() external onlyOwner {\n        _pause();\n    }\n\n    /// @notice Re-enables claim entrypoints.\n    /// @dev Only the owner may unpause.\n    function unpause() external onlyOwner {\n        _unpause();\n    }\n\n    /// @notice Accepts native-token funding so the contract can be pre-funded for ETH claims.\n    /// @dev Any ETH sent here that does not correspond to a claim leaf is permanently locked.\n    receive() external payable {}\n\n    /// @notice Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`.\n    /// @param index The index of the claim leaf.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    function claim(uint256 index, address token, uint256 amount, bytes32[] calldata merkleProof)\n        external\n        whenNotPaused\n    {\n        _claim(index, msg.sender, token, amount, merkleProof);\n    }\n\n    /// @notice Permissionless claim path; any caller can trigger the claim for `claimant`, and\n    /// funds are transferred to `claimant` (as bound by the Merkle leaf).\n    /// @param index The index of the claim leaf.\n    /// @param claimant The address encoded in the Merkle leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    function claimTo(uint256 index, address claimant, address token, uint256 amount, bytes32[] calldata merkleProof)\n        external\n        whenNotPaused\n    {\n        _claim(index, claimant, token, amount, merkleProof);\n    }\n\n    /// @notice Executes a single claim after verifying the leaf against the Merkle root.\n    /// @param index The index of the claim leaf.\n    /// @param claimant The address encoded in the Merkle leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    /// @dev Internal entrypoint used by `claim` and `claimTo`. Batching across multiple leaves\n    /// is expected to be composed at the call site via Multicall3 (or equivalent) rather than\n    /// via a contract-level helper.\n    /// Marks the index as claimed before transferring funds (checks-effects-interactions).\n    function _claim(uint256 index, address claimant, address token, uint256 amount, bytes32[] calldata merkleProof)\n        internal\n        claimWindowOpen\n        notClaimed(index)\n    {\n        bytes32 leaf = keccak256(abi.encodePacked(index, claimant, token, amount));\n\n        if (!MerkleProofUpgradeable.verifyCalldata(merkleProof, MERKLE_ROOT, leaf)) {\n            revert ZkSyncLiteSunsetClaimDistributor__InvalidProof();\n        }\n\n        claimedBitMap.set(index);\n        _transferClaim(claimant, token, amount);\n        emit Claimed(index, claimant, token, amount);\n    }\n\n    /// @notice Transfers the claim amount to `claimant`.\n    /// @param claimant The address the funds are transferred to.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @dev Routes ERC-20 via SafeERC20 and native-token via `call{value:}`; reverts with\n    /// `__EthTransferFailed` if the native transfer fails.\n    function _transferClaim(address claimant, address token, uint256 amount) internal {\n        // `token == address(0)` is reserved for native ETH claims.\n        if (token == address(0)) {\n            (bool success,) = claimant.call{value: amount}(\"\");\n            if (!success) {\n                revert ZkSyncLiteSunsetClaimDistributor__EthTransferFailed();\n            }\n        } else {\n            IERC20Upgradeable(token).safeTransfer(claimant, amount);\n        }\n    }\n\n    /// @dev Reverts if `block.timestamp < WINDOW_START`.\n    modifier claimWindowOpen() {\n        if (block.timestamp < WINDOW_START) {\n            revert ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen();\n        }\n        _;\n    }\n\n    /// @dev Reverts if the given `index` has already been consumed.\n    modifier notClaimed(uint256 index) {\n        if (isClaimed(index)) {\n            revert ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed();\n        }\n        _;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    function __Ownable_init() internal onlyInitializing {\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal onlyInitializing {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    function __Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __Pausable_init_unchained() internal onlyInitializing {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/BitMaps.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.\n * Largely inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].\n */\nlibrary BitMapsUpgradeable {\n    struct BitMap {\n        mapping(uint256 => uint256) _data;\n    }\n\n    /**\n     * @dev Returns whether the bit at `index` is set.\n     */\n    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        return bitmap._data[bucket] & mask != 0;\n    }\n\n    /**\n     * @dev Sets the bit at `index` to the boolean `value`.\n     */\n    function setTo(BitMap storage bitmap, uint256 index, bool value) internal {\n        if (value) {\n            set(bitmap, index);\n        } else {\n            unset(bitmap, index);\n        }\n    }\n\n    /**\n     * @dev Sets the bit at `index`.\n     */\n    function set(BitMap storage bitmap, uint256 index) internal {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        bitmap._data[bucket] |= mask;\n    }\n\n    /**\n     * @dev Unsets the bit at `index`.\n     */\n    function unset(BitMap storage bitmap, uint256 index) internal {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        bitmap._data[bucket] &= ~mask;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Tree proofs.\n *\n * The tree and the proofs can be generated using our\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\n * You will find a quickstart guide in the readme.\n *\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\n * hashing, or use a hash function other than keccak256 for hashing leaves.\n * This is because the concatenation of a sorted pair of internal nodes in\n * the merkle tree could be reinterpreted as a leaf value.\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\n * against this attack out of the box.\n */\nlibrary MerkleProofUpgradeable {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Calldata version of {verify}\n     *\n     * _Available since v4.7._\n     */\n    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProofCalldata(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Calldata version of {processProof}\n     *\n     * _Available since v4.7._\n     */\n    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by\n     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerify(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProof(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Calldata version of {multiProofVerify}\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerifyCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProofCalldata(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction\n     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another\n     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false\n     * respectively.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree\n     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the\n     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProof(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    /**\n     * @dev Calldata version of {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProofCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\n        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.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 IERC20Upgradeable {\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"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.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 \"../IERC20Upgradeable.sol\";\nimport \"../extensions/IERC20PermitUpgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.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 SafeERC20Upgradeable {\n    using AddressUpgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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        IERC20PermitUpgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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))) && AddressUpgradeable.isContract(address(token));\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20PermitUpgradeable {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.24+commit.e11b9ed9","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris","remappings":["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","flexible-voting/=lib/zk-governance/l2-contracts/lib/flexible-voting/","forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","murky/=lib/zk-governance/l2-contracts/lib/murky/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts/=lib/openzeppelin-contracts/","openzeppelin/=lib/openzeppelin-contracts/contracts/","solmate/=lib/zk-governance/l2-contracts/lib/flexible-voting/lib/solmate/src/","zk-governance/=lib/zk-governance/"]},"name":"ZkSyncLiteSunsetClaimDistributorL1","fullyQualifiedName":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__InvalidProof","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claimant","type":"address","indexed":false,"internalType":"address"},{"name":"token","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"MERKLE_ROOT","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"WINDOW_START","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"merkleProof","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimTo","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"claimant","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"merkleProof","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"initialize","type":"function","inputs":[{"name":"merkleRoot","type":"bytes32","internalType":"bytes32"},{"name":"windowStart","type":"uint256","internalType":"uint256"},{"name":"initialOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isClaimed","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.24+commit.e11b9ed9"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed","type":"error"},{"inputs":[],"name":"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen","type":"error"},{"inputs":[],"name":"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed","type":"error"},{"inputs":[],"name":"ZkSyncLiteSunsetClaimDistributor__InvalidProof","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"address","name":"claimant","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"MERKLE_ROOT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WINDOW_START","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"claimant","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claimTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"windowStart","type":"uint256"},{"internalType":"address","name":"initialOwner","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"author":"Matter Labs","custom:security-contact":"security@matterlabs.dev","details":"Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`. `token == address(0)` denotes a native ETH claim. Leaf indices must be globally unique across all leaves because the claimed bitmap is keyed only by `index`.Expected to be deployed as a TransparentUpgradeableProxy.","events":{"Claimed(uint256,address,address,uint256)":{"params":{"amount":"The amount transferred to the claimant.","claimant":"The address encoded in the leaf and receiving the funds.","index":"The index of the claim leaf that was consumed.","token":"The token address (use `address(0)` for native ETH)."}},"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"kind":"dev","methods":{"claim(uint256,address,uint256,bytes32[])":{"params":{"amount":"The amount to transfer.","index":"The index of the claim leaf.","merkleProof":"The Merkle proof for the claim leaf.","token":"The token address (use `address(0)` for native ETH)."}},"claimTo(uint256,address,address,uint256,bytes32[])":{"params":{"amount":"The amount to transfer.","claimant":"The address encoded in the Merkle leaf and receiving the funds.","index":"The index of the claim leaf.","merkleProof":"The Merkle proof for the claim leaf.","token":"The token address (use `address(0)` for native ETH)."}},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"initialize(bytes32,uint256,address)":{"details":"Transfers ownership to `initialOwner` if different from the proxy deployer that invokes this initializer.","params":{"initialOwner":"Owner allowed to pause and unpause claiming.","merkleRoot":"Merkle root for the claim dataset.","windowStart":"Claim start timestamp (inclusive)."}},"isClaimed(uint256)":{"params":{"index":"The index of the claim leaf."},"returns":{"_0":"Whether the claim has been executed."}},"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"Only the owner may pause; halts every claim path until `unpause` is called."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"unpause()":{"details":"Only the owner may unpause."}},"title":"ZkSyncLiteSunsetClaimDistributorL1","version":1},"userdoc":{"errors":{"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed()":[{"notice":"Thrown when the claim index has already been consumed."}],"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen()":[{"notice":"Thrown when the claim window is not yet open."}],"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed()":[{"notice":"Thrown when the native-token transfer to the claimant reverts."}],"ZkSyncLiteSunsetClaimDistributor__InvalidProof()":[{"notice":"Thrown when the Merkle proof does not verify against `MERKLE_ROOT`."}]},"events":{"Claimed(uint256,address,address,uint256)":{"notice":"Emitted whenever a call to claim succeeds."}},"kind":"user","methods":{"MERKLE_ROOT()":{"notice":"Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`."},"WINDOW_START()":{"notice":"Claims are enabled at/after this timestamp."},"claim(uint256,address,uint256,bytes32[])":{"notice":"Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`."},"claimTo(uint256,address,address,uint256,bytes32[])":{"notice":"Permissionless claim path; any caller can trigger the claim for `claimant`, and funds are transferred to `claimant` (as bound by the Merkle leaf)."},"constructor":{"notice":"Disables initializers on the implementation so it can only be used behind a proxy."},"initialize(bytes32,uint256,address)":{"notice":"Initializes proxy storage."},"isClaimed(uint256)":{"notice":"Returns whether a claim index has already been consumed."},"pause()":{"notice":"Pauses all claim entrypoints."},"unpause()":{"notice":"Re-enables claim entrypoints."}},"notice":"L1 distributor for the ZKsync Lite sunset. Funds committed in a Merkle tree can be claimed either by the claimant themselves or by any caller on behalf of the claimant; in both cases the funds are transferred to the claimant encoded in the leaf.","version":1}},"settings":{"compilationTarget":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":"ZkSyncLiteSunsetClaimDistributorL1"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":flexible-voting/=lib/zk-governance/l2-contracts/lib/flexible-voting/",":forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/",":murky/=lib/zk-governance/l2-contracts/lib/murky/",":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":openzeppelin/=lib/openzeppelin-contracts/contracts/",":solmate/=lib/zk-governance/l2-contracts/lib/flexible-voting/lib/solmate/src/",":zk-governance/=lib/zk-governance/"],"viaIR":true},"sources":{"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"keccak256":"0x359a1ab89b46b9aba7bcad3fb651924baf4893d15153049b9976b0fc9be1358e","license":"MIT","urls":["bzz-raw://e89863421b4014b96a4b62be76eb3b9f0a8afe9684664a6f389124c0964bfe5c","dweb:/ipfs/Qmbk7xr1irpDuU1WdxXgxELBXxs61rHhCgod7heVcvFx16"]},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"keccak256":"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794","license":"MIT","urls":["bzz-raw://f103ee2e4aecd37aac6ceefe670709cdd7613dee25fa2d4d9feaf7fc0aaa155e","dweb:/ipfs/QmRiNZLoJk5k3HPMYGPGjZFd2ke1ZxjhJZkM45Ec9GH9hv"]},"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol":{"keccak256":"0xad32f6821f860555f9530902a65b54203a4f5db2117f4384ae47a124958078db","license":"MIT","urls":["bzz-raw://6d362da7417bc7d7cc8623f3d3f8f04c3808d043ee6379568c63a63ec14a124e","dweb:/ipfs/QmYm3wDHUcfGh3MNiRqpWEBbSSYnDSyUsppDATy5DVsfui"]},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol":{"keccak256":"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f","license":"MIT","urls":["bzz-raw://c25f742ff154998d19a669e2508c3597b363e123ce9144cd0fcf6521229f401f","dweb:/ipfs/QmQXRuFzStEWqeEPbhQU6cAg9PaSowxJVo4PDKyRod7dco"]},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol":{"keccak256":"0x07e881de3b9f6d2c07909f193f24b96c7fe4ea60013260f3f25aecd8bab3c2f8","license":"MIT","urls":["bzz-raw://1fed09b97ccb0ff9ba9b6a94224f1d489026bf6b4b7279bfe64fb6e8749dee4d","dweb:/ipfs/QmcRAzaSP1UnGr4vrGkfJmB2L9aiTYoXfV1Lg9gqrVRWn8"]},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.sol":{"keccak256":"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5","license":"MIT","urls":["bzz-raw://d03ebe5406134f0c4a017dee625ff615031194493bd1e88504e5c8fae55bc166","dweb:/ipfs/QmUZV5bMbgk2PAkV3coouSeSainHN2jhqaQDJaA7hQRyu2"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol":{"keccak256":"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422","license":"MIT","urls":["bzz-raw://310136ad60820af4177a11a61d77a3686faf5fca4942b600e08fc940db38396b","dweb:/ipfs/QmbCzMNSTL7Zi7M4UCSqBrkHtp4jjxUnGbkneCZKdR1qeq"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"keccak256":"0x75097e35253e7fb282ee4d7f27a80eaacfa759923185bf17302a89cbc059c5ef","license":"MIT","urls":["bzz-raw://8b06267c5f80bad727af3e48b1382333d591dad51376399ef2f6b0ee6d58bf95","dweb:/ipfs/QmdU5La1agcQvghnfMpWZGDPz2TUDTCxUwTLKmuMRXBpAx"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol":{"keccak256":"0xb89d1b9c2f50f58a812202138ddb7dd147a2f8bb09846f4420cb4909dec62220","license":"MIT","urls":["bzz-raw://125d6353568da46a9c09ad2854a5ac08dffe0befaf991068d40775a2fe490682","dweb:/ipfs/QmZuCkiiAnWm1LB3KxH71w7kJeDPWvDZM6xjyHoc5ihPwB"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol":{"keccak256":"0x07aab61872a5dd56d876a8d8f82f4cc063e74d16ec9f1eff100fcaee423b5de9","license":"MIT","urls":["bzz-raw://399cf9ed2bce652a340c0336a2a426c88ad593aa989b4bb239d0ba44385d66a4","dweb:/ipfs/QmVCKpLx1qJ16iMvjA2ZLT2b9iGRq3ybVQN3RxoUgwMwxn"]},"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"keccak256":"0x4ee358ba4a7305f380f2f8cd50e99784bb4bf705777107cdf8138e5402afcce6","license":"MIT","urls":["bzz-raw://0e1959fa24a8d3f55357779aeefb9e86148ff22fab3dda9663cd28f87b4a72d1","dweb:/ipfs/QmdiGp59TPfxe48gXZ44fT6B9zPFgPn3y6iaA7zLsVsBrX"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint256)49_storage":{"base":"t_uint256","label":"uint256[49]","encoding":"inplace","numberOfBytes":"1568"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_struct(BitMap)1836_storage":{"label":"struct BitMapsUpgradeable.BitMap","members":[{"slot":"0","type":"t_mapping(t_uint256,t_uint256)","astId":1835,"label":"_data","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint256)":{"key":"t_uint256","label":"mapping(uint256 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":139,"label":"_initialized","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"0","type":"t_bool","astId":142,"label":"_initializing","offset":1,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":1299,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"51","type":"t_address","astId":11,"label":"_owner","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"52","type":"t_array(t_uint256)49_storage","astId":131,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"101","type":"t_bool","astId":323,"label":"_paused","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"102","type":"t_array(t_uint256)49_storage","astId":428,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"151","type":"t_bytes32","astId":2000,"label":"MERKLE_ROOT","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"152","type":"t_uint256","astId":2003,"label":"WINDOW_START","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"153","type":"t_struct(BitMap)1836_storage","astId":2007,"label":"claimedBitMap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"ZkSyncLiteSunsetClaimDistributor__InvalidProof()":[{"notice":"Thrown when the Merkle proof does not verify against `MERKLE_ROOT`."}],"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed()":[{"notice":"Thrown when the claim index has already been consumed."}],"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed()":[{"notice":"Thrown when the native-token transfer to the claimant reverts."}],"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen()":[{"notice":"Thrown when the claim window is not yet open."}]},"events":{"Claimed(uint256,address,address,uint256)":{"notice":"Emitted whenever a call to claim succeeds."}},"notice":"L1 distributor for the ZKsync Lite sunset. Funds committed in a Merkle tree can be claimed either by the claimant themselves or by any caller on behalf of the claimant; in both cases the funds are transferred to the claimant encoded in the leaf.","methods":{"pause()":{"notice":"Pauses all claim entrypoints."},"unpause()":{"notice":"Re-enables claim entrypoints."},"constructor":{"notice":"Disables initializers on the implementation so it can only be used behind a proxy."},"MERKLE_ROOT()":{"notice":"Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`."},"WINDOW_START()":{"notice":"Claims are enabled at/after this timestamp."},"isClaimed(uint256)":{"notice":"Returns whether a claim index has already been consumed."},"initialize(bytes32,uint256,address)":{"notice":"Initializes proxy storage."},"claim(uint256,address,uint256,bytes32[])":{"notice":"Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`."},"claimTo(uint256,address,address,uint256,bytes32[])":{"notice":"Permissionless claim path; any caller can trigger the claim for `claimant`, and funds are transferred to `claimant` (as bound by the Merkle leaf)."}},"version":1},"devdoc":{"kind":"dev","title":"ZkSyncLiteSunsetClaimDistributorL1","author":"Matter Labs","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Claimed(uint256,address,address,uint256)":{"params":{"index":"The index of the claim leaf that was consumed.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount transferred to the claimant.","claimant":"The address encoded in the leaf and receiving the funds."}}},"details":"Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`. `token == address(0)` denotes a native ETH claim. Leaf indices must be globally unique across all leaves because the claimed bitmap is keyed only by `index`.Expected to be deployed as a TransparentUpgradeableProxy.","methods":{"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"Only the owner may pause; halts every claim path until `unpause` is called."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"unpause()":{"details":"Only the owner may unpause."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"isClaimed(uint256)":{"params":{"index":"The index of the claim leaf."},"returns":{"_0":"Whether the claim has been executed."}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"initialize(bytes32,uint256,address)":{"params":{"merkleRoot":"Merkle root for the claim dataset.","windowStart":"Claim start timestamp (inclusive).","initialOwner":"Owner allowed to pause and unpause claiming."},"details":"Transfers ownership to `initialOwner` if different from the proxy deployer that invokes this initializer."},"claim(uint256,address,uint256,bytes32[])":{"params":{"index":"The index of the claim leaf.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount to transfer.","merkleProof":"The Merkle proof for the claim leaf."}},"claimTo(uint256,address,address,uint256,bytes32[])":{"params":{"index":"The index of the claim leaf.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount to transfer.","claimant":"The address encoded in the Merkle leaf and receiving the funds.","merkleProof":"The Merkle proof for the claim leaf."}}},"version":1,"custom:security-contact":"security@matterlabs.dev"},"sourceIds":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"id":10},"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol":{"id":6},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"id":7},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"id":0},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"id":1},"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol":{"id":2},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol":{"id":3},"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol":{"id":9},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.sol":{"id":5},"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol":{"id":8},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.24;\n\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport {OwnableUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport {PausableUpgradeable} from \"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\";\nimport {BitMapsUpgradeable} from \"@openzeppelin/contracts-upgradeable/utils/structs/BitMapsUpgradeable.sol\";\nimport {\n    MerkleProofUpgradeable\n} from \"@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol\";\nimport {IERC20Upgradeable} from \"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\";\nimport {SafeERC20Upgradeable} from \"@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol\";\n\n/// @title ZkSyncLiteSunsetClaimDistributorL1\n/// @author Matter Labs\n/// @custom:security-contact security@matterlabs.dev\n/// @notice L1 distributor for the ZKsync Lite sunset. Funds committed in a\n/// Merkle tree can be claimed either by the claimant themselves or by any caller\n/// on behalf of the claimant; in both cases the funds are transferred to the\n/// claimant encoded in the leaf.\n/// @dev Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`.\n/// `token == address(0)` denotes a native ETH claim. Leaf indices must be globally\n/// unique across all leaves because the claimed bitmap is keyed only by `index`.\n/// @dev Expected to be deployed as a TransparentUpgradeableProxy.\ncontract ZkSyncLiteSunsetClaimDistributorL1 is Initializable, OwnableUpgradeable, PausableUpgradeable {\n    using BitMapsUpgradeable for BitMapsUpgradeable.BitMap;\n    using SafeERC20Upgradeable for IERC20Upgradeable;\n\n    /// @notice Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`.\n    bytes32 public MERKLE_ROOT;\n    /// @notice Claims are enabled at/after this timestamp.\n    uint256 public WINDOW_START;\n    /// @notice Packed bitmap tracking completion of claims per leaf index.\n    BitMapsUpgradeable.BitMap internal claimedBitMap;\n\n    /// @notice Emitted whenever a call to claim succeeds.\n    /// @param index The index of the claim leaf that was consumed.\n    /// @param claimant The address encoded in the leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount transferred to the claimant.\n    event Claimed(uint256 index, address claimant, address token, uint256 amount);\n\n    /// @notice Thrown when the claim index has already been consumed.\n    error ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed();\n    /// @notice Thrown when the claim window is not yet open.\n    error ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen();\n    /// @notice Thrown when the Merkle proof does not verify against `MERKLE_ROOT`.\n    error ZkSyncLiteSunsetClaimDistributor__InvalidProof();\n    /// @notice Thrown when the native-token transfer to the claimant reverts.\n    error ZkSyncLiteSunsetClaimDistributor__EthTransferFailed();\n\n    /// @notice Disables initializers on the implementation so it can only be used behind a proxy.\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n    /// @notice Initializes proxy storage.\n    /// @param merkleRoot Merkle root for the claim dataset.\n    /// @param windowStart Claim start timestamp (inclusive).\n    /// @param initialOwner Owner allowed to pause and unpause claiming.\n    /// @dev Transfers ownership to `initialOwner` if different from the proxy deployer\n    /// that invokes this initializer.\n    function initialize(bytes32 merkleRoot, uint256 windowStart, address initialOwner) external initializer {\n        require(initialOwner != address(0), \"Ownable: new owner is the zero address\");\n\n        __Ownable_init();\n        __Pausable_init();\n\n        if (initialOwner != _msgSender()) {\n            _transferOwnership(initialOwner);\n        }\n\n        MERKLE_ROOT = merkleRoot;\n        WINDOW_START = windowStart;\n    }\n\n    /// @notice Returns whether a claim index has already been consumed.\n    /// @param index The index of the claim leaf.\n    /// @return Whether the claim has been executed.\n    function isClaimed(uint256 index) public view returns (bool) {\n        return claimedBitMap.get(index);\n    }\n\n    /// @notice Pauses all claim entrypoints.\n    /// @dev Only the owner may pause; halts every claim path until `unpause` is called.\n    function pause() external onlyOwner {\n        _pause();\n    }\n\n    /// @notice Re-enables claim entrypoints.\n    /// @dev Only the owner may unpause.\n    function unpause() external onlyOwner {\n        _unpause();\n    }\n\n    /// @notice Accepts native-token funding so the contract can be pre-funded for ETH claims.\n    /// @dev Any ETH sent here that does not correspond to a claim leaf is permanently locked.\n    receive() external payable {}\n\n    /// @notice Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`.\n    /// @param index The index of the claim leaf.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    function claim(uint256 index, address token, uint256 amount, bytes32[] calldata merkleProof)\n        external\n        whenNotPaused\n    {\n        _claim(index, msg.sender, token, amount, merkleProof);\n    }\n\n    /// @notice Permissionless claim path; any caller can trigger the claim for `claimant`, and\n    /// funds are transferred to `claimant` (as bound by the Merkle leaf).\n    /// @param index The index of the claim leaf.\n    /// @param claimant The address encoded in the Merkle leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    function claimTo(uint256 index, address claimant, address token, uint256 amount, bytes32[] calldata merkleProof)\n        external\n        whenNotPaused\n    {\n        _claim(index, claimant, token, amount, merkleProof);\n    }\n\n    /// @notice Executes a single claim after verifying the leaf against the Merkle root.\n    /// @param index The index of the claim leaf.\n    /// @param claimant The address encoded in the Merkle leaf and receiving the funds.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @param merkleProof The Merkle proof for the claim leaf.\n    /// @dev Internal entrypoint used by `claim` and `claimTo`. Batching across multiple leaves\n    /// is expected to be composed at the call site via Multicall3 (or equivalent) rather than\n    /// via a contract-level helper.\n    /// Marks the index as claimed before transferring funds (checks-effects-interactions).\n    function _claim(uint256 index, address claimant, address token, uint256 amount, bytes32[] calldata merkleProof)\n        internal\n        claimWindowOpen\n        notClaimed(index)\n    {\n        bytes32 leaf = keccak256(abi.encodePacked(index, claimant, token, amount));\n\n        if (!MerkleProofUpgradeable.verifyCalldata(merkleProof, MERKLE_ROOT, leaf)) {\n            revert ZkSyncLiteSunsetClaimDistributor__InvalidProof();\n        }\n\n        claimedBitMap.set(index);\n        _transferClaim(claimant, token, amount);\n        emit Claimed(index, claimant, token, amount);\n    }\n\n    /// @notice Transfers the claim amount to `claimant`.\n    /// @param claimant The address the funds are transferred to.\n    /// @param token The token address (use `address(0)` for native ETH).\n    /// @param amount The amount to transfer.\n    /// @dev Routes ERC-20 via SafeERC20 and native-token via `call{value:}`; reverts with\n    /// `__EthTransferFailed` if the native transfer fails.\n    function _transferClaim(address claimant, address token, uint256 amount) internal {\n        // `token == address(0)` is reserved for native ETH claims.\n        if (token == address(0)) {\n            (bool success,) = claimant.call{value: amount}(\"\");\n            if (!success) {\n                revert ZkSyncLiteSunsetClaimDistributor__EthTransferFailed();\n            }\n        } else {\n            IERC20Upgradeable(token).safeTransfer(claimant, amount);\n        }\n    }\n\n    /// @dev Reverts if `block.timestamp < WINDOW_START`.\n    modifier claimWindowOpen() {\n        if (block.timestamp < WINDOW_START) {\n            revert ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen();\n        }\n        _;\n    }\n\n    /// @dev Reverts if the given `index` has already been consumed.\n    modifier notClaimed(uint256 index) {\n        if (isClaimed(index)) {\n            revert ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed();\n        }\n        _;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    function __Ownable_init() internal onlyInitializing {\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal onlyInitializing {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    function __Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __Pausable_init_unchained() internal onlyInitializing {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.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 IERC20Upgradeable {\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"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/BitMaps.sol)\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.\n * Largely inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].\n */\nlibrary BitMapsUpgradeable {\n    struct BitMap {\n        mapping(uint256 => uint256) _data;\n    }\n\n    /**\n     * @dev Returns whether the bit at `index` is set.\n     */\n    function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        return bitmap._data[bucket] & mask != 0;\n    }\n\n    /**\n     * @dev Sets the bit at `index` to the boolean `value`.\n     */\n    function setTo(BitMap storage bitmap, uint256 index, bool value) internal {\n        if (value) {\n            set(bitmap, index);\n        } else {\n            unset(bitmap, index);\n        }\n    }\n\n    /**\n     * @dev Sets the bit at `index`.\n     */\n    function set(BitMap storage bitmap, uint256 index) internal {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        bitmap._data[bucket] |= mask;\n    }\n\n    /**\n     * @dev Unsets the bit at `index`.\n     */\n    function unset(BitMap storage bitmap, uint256 index) internal {\n        uint256 bucket = index >> 8;\n        uint256 mask = 1 << (index & 0xff);\n        bitmap._data[bucket] &= ~mask;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.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 \"../IERC20Upgradeable.sol\";\nimport \"../extensions/IERC20PermitUpgradeable.sol\";\nimport \"../../../utils/AddressUpgradeable.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 SafeERC20Upgradeable {\n    using AddressUpgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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        IERC20PermitUpgradeable 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(IERC20Upgradeable 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(IERC20Upgradeable 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))) && AddressUpgradeable.isContract(address(token));\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Tree proofs.\n *\n * The tree and the proofs can be generated using our\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\n * You will find a quickstart guide in the readme.\n *\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\n * hashing, or use a hash function other than keccak256 for hashing leaves.\n * This is because the concatenation of a sorted pair of internal nodes in\n * the merkle tree could be reinterpreted as a leaf value.\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\n * against this attack out of the box.\n */\nlibrary MerkleProofUpgradeable {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Calldata version of {verify}\n     *\n     * _Available since v4.7._\n     */\n    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProofCalldata(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Calldata version of {processProof}\n     *\n     * _Available since v4.7._\n     */\n    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by\n     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerify(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProof(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Calldata version of {multiProofVerify}\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerifyCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProofCalldata(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction\n     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another\n     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false\n     * respectively.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree\n     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the\n     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProof(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    /**\n     * @dev Calldata version of {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProofCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\n        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20PermitUpgradeable {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris","remappings":["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/","ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","flexible-voting/=lib/zk-governance/l2-contracts/lib/flexible-voting/","forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","murky/=lib/zk-governance/l2-contracts/lib/murky/","openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts/=lib/openzeppelin-contracts/","openzeppelin/=lib/openzeppelin-contracts/contracts/","solmate/=lib/zk-governance/l2-contracts/lib/flexible-voting/lib/solmate/src/","zk-governance/=lib/zk-governance/"]}},"stdJsonOutput":{"sources":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"id":10},"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol":{"id":6},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"id":7},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"id":0},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"id":1},"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol":{"id":2},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol":{"id":3},"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol":{"id":9},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.sol":{"id":5},"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol":{"id":8},"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol":{"id":4}},"contracts":{"src/ZkSyncLiteSunsetClaimDistributorL1.sol":{"ZkSyncLiteSunsetClaimDistributorL1":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed","type":"error","inputs":[]},{"name":"ZkSyncLiteSunsetClaimDistributor__InvalidProof","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"claimant","type":"address","indexed":false,"internalType":"address"},{"name":"token","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"MERKLE_ROOT","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"WINDOW_START","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"merkleProof","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimTo","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"claimant","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"merkleProof","type":"bytes32[]","internalType":"bytes32[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"initialize","type":"function","inputs":[{"name":"merkleRoot","type":"bytes32","internalType":"bytes32"},{"name":"windowStart","type":"uint256","internalType":"uint256"},{"name":"initialOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isClaimed","type":"function","inputs":[{"name":"index","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.24+commit.e11b9ed9\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZkSyncLiteSunsetClaimDistributor__InvalidProof\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"claimant\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MERKLE_ROOT\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WINDOW_START\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"merkleProof\",\"type\":\"bytes32[]\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"claimant\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"merkleProof\",\"type\":\"bytes32[]\"}],\"name\":\"claimTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"merkleRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"windowStart\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"isClaimed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"author\":\"Matter Labs\",\"custom:security-contact\":\"security@matterlabs.dev\",\"details\":\"Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`. `token == address(0)` denotes a native ETH claim. Leaf indices must be globally unique across all leaves because the claimed bitmap is keyed only by `index`.Expected to be deployed as a TransparentUpgradeableProxy.\",\"events\":{\"Claimed(uint256,address,address,uint256)\":{\"params\":{\"amount\":\"The amount transferred to the claimant.\",\"claimant\":\"The address encoded in the leaf and receiving the funds.\",\"index\":\"The index of the claim leaf that was consumed.\",\"token\":\"The token address (use `address(0)` for native ETH).\"}},\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"},\"Paused(address)\":{\"details\":\"Emitted when the pause is triggered by `account`.\"},\"Unpaused(address)\":{\"details\":\"Emitted when the pause is lifted by `account`.\"}},\"kind\":\"dev\",\"methods\":{\"claim(uint256,address,uint256,bytes32[])\":{\"params\":{\"amount\":\"The amount to transfer.\",\"index\":\"The index of the claim leaf.\",\"merkleProof\":\"The Merkle proof for the claim leaf.\",\"token\":\"The token address (use `address(0)` for native ETH).\"}},\"claimTo(uint256,address,address,uint256,bytes32[])\":{\"params\":{\"amount\":\"The amount to transfer.\",\"claimant\":\"The address encoded in the Merkle leaf and receiving the funds.\",\"index\":\"The index of the claim leaf.\",\"merkleProof\":\"The Merkle proof for the claim leaf.\",\"token\":\"The token address (use `address(0)` for native ETH).\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"initialize(bytes32,uint256,address)\":{\"details\":\"Transfers ownership to `initialOwner` if different from the proxy deployer that invokes this initializer.\",\"params\":{\"initialOwner\":\"Owner allowed to pause and unpause claiming.\",\"merkleRoot\":\"Merkle root for the claim dataset.\",\"windowStart\":\"Claim start timestamp (inclusive).\"}},\"isClaimed(uint256)\":{\"params\":{\"index\":\"The index of the claim leaf.\"},\"returns\":{\"_0\":\"Whether the claim has been executed.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pause()\":{\"details\":\"Only the owner may pause; halts every claim path until `unpause` is called.\"},\"paused()\":{\"details\":\"Returns true if the contract is paused, and false otherwise.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"unpause()\":{\"details\":\"Only the owner may unpause.\"}},\"title\":\"ZkSyncLiteSunsetClaimDistributorL1\",\"version\":1},\"userdoc\":{\"errors\":{\"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed()\":[{\"notice\":\"Thrown when the claim index has already been consumed.\"}],\"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen()\":[{\"notice\":\"Thrown when the claim window is not yet open.\"}],\"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed()\":[{\"notice\":\"Thrown when the native-token transfer to the claimant reverts.\"}],\"ZkSyncLiteSunsetClaimDistributor__InvalidProof()\":[{\"notice\":\"Thrown when the Merkle proof does not verify against `MERKLE_ROOT`.\"}]},\"events\":{\"Claimed(uint256,address,address,uint256)\":{\"notice\":\"Emitted whenever a call to claim succeeds.\"}},\"kind\":\"user\",\"methods\":{\"MERKLE_ROOT()\":{\"notice\":\"Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`.\"},\"WINDOW_START()\":{\"notice\":\"Claims are enabled at/after this timestamp.\"},\"claim(uint256,address,uint256,bytes32[])\":{\"notice\":\"Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`.\"},\"claimTo(uint256,address,address,uint256,bytes32[])\":{\"notice\":\"Permissionless claim path; any caller can trigger the claim for `claimant`, and funds are transferred to `claimant` (as bound by the Merkle leaf).\"},\"constructor\":{\"notice\":\"Disables initializers on the implementation so it can only be used behind a proxy.\"},\"initialize(bytes32,uint256,address)\":{\"notice\":\"Initializes proxy storage.\"},\"isClaimed(uint256)\":{\"notice\":\"Returns whether a claim index has already been consumed.\"},\"pause()\":{\"notice\":\"Pauses all claim entrypoints.\"},\"unpause()\":{\"notice\":\"Re-enables claim entrypoints.\"}},\"notice\":\"L1 distributor for the ZKsync Lite sunset. Funds committed in a Merkle tree can be claimed either by the claimant themselves or by any caller on behalf of the claimant; in both cases the funds are transferred to the claimant encoded in the leaf.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/ZkSyncLiteSunsetClaimDistributorL1.sol\":\"ZkSyncLiteSunsetClaimDistributorL1\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":flexible-voting/=lib/zk-governance/l2-contracts/lib/flexible-voting/\",\":forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/\",\":murky/=lib/zk-governance/l2-contracts/lib/murky/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":solmate/=lib/zk-governance/l2-contracts/lib/flexible-voting/lib/solmate/src/\",\":zk-governance/=lib/zk-governance/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol\":{\"keccak256\":\"0x359a1ab89b46b9aba7bcad3fb651924baf4893d15153049b9976b0fc9be1358e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e89863421b4014b96a4b62be76eb3b9f0a8afe9684664a6f389124c0964bfe5c\",\"dweb:/ipfs/Qmbk7xr1irpDuU1WdxXgxELBXxs61rHhCgod7heVcvFx16\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol\":{\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f103ee2e4aecd37aac6ceefe670709cdd7613dee25fa2d4d9feaf7fc0aaa155e\",\"dweb:/ipfs/QmRiNZLoJk5k3HPMYGPGjZFd2ke1ZxjhJZkM45Ec9GH9hv\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol\":{\"keccak256\":\"0xad32f6821f860555f9530902a65b54203a4f5db2117f4384ae47a124958078db\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6d362da7417bc7d7cc8623f3d3f8f04c3808d043ee6379568c63a63ec14a124e\",\"dweb:/ipfs/QmYm3wDHUcfGh3MNiRqpWEBbSSYnDSyUsppDATy5DVsfui\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol\":{\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c25f742ff154998d19a669e2508c3597b363e123ce9144cd0fcf6521229f401f\",\"dweb:/ipfs/QmQXRuFzStEWqeEPbhQU6cAg9PaSowxJVo4PDKyRod7dco\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/IERC20PermitUpgradeable.sol\":{\"keccak256\":\"0x07e881de3b9f6d2c07909f193f24b96c7fe4ea60013260f3f25aecd8bab3c2f8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1fed09b97ccb0ff9ba9b6a94224f1d489026bf6b4b7279bfe64fb6e8749dee4d\",\"dweb:/ipfs/QmcRAzaSP1UnGr4vrGkfJmB2L9aiTYoXfV1Lg9gqrVRWn8\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/token/ERC20/utils/SafeERC20Upgradeable.sol\":{\"keccak256\":\"0x23b997be73d3dd46885262704f0f8cfc7273fdadfe303d37969a9561373972b5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d03ebe5406134f0c4a017dee625ff615031194493bd1e88504e5c8fae55bc166\",\"dweb:/ipfs/QmUZV5bMbgk2PAkV3coouSeSainHN2jhqaQDJaA7hQRyu2\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol\":{\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://310136ad60820af4177a11a61d77a3686faf5fca4942b600e08fc940db38396b\",\"dweb:/ipfs/QmbCzMNSTL7Zi7M4UCSqBrkHtp4jjxUnGbkneCZKdR1qeq\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol\":{\"keccak256\":\"0x75097e35253e7fb282ee4d7f27a80eaacfa759923185bf17302a89cbc059c5ef\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8b06267c5f80bad727af3e48b1382333d591dad51376399ef2f6b0ee6d58bf95\",\"dweb:/ipfs/QmdU5La1agcQvghnfMpWZGDPz2TUDTCxUwTLKmuMRXBpAx\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol\":{\"keccak256\":\"0xb89d1b9c2f50f58a812202138ddb7dd147a2f8bb09846f4420cb4909dec62220\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://125d6353568da46a9c09ad2854a5ac08dffe0befaf991068d40775a2fe490682\",\"dweb:/ipfs/QmZuCkiiAnWm1LB3KxH71w7kJeDPWvDZM6xjyHoc5ihPwB\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/structs/BitMapsUpgradeable.sol\":{\"keccak256\":\"0x07aab61872a5dd56d876a8d8f82f4cc063e74d16ec9f1eff100fcaee423b5de9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://399cf9ed2bce652a340c0336a2a426c88ad593aa989b4bb239d0ba44385d66a4\",\"dweb:/ipfs/QmVCKpLx1qJ16iMvjA2ZLT2b9iGRq3ybVQN3RxoUgwMwxn\"]},\"src/ZkSyncLiteSunsetClaimDistributorL1.sol\":{\"keccak256\":\"0x4ee358ba4a7305f380f2f8cd50e99784bb4bf705777107cdf8138e5402afcce6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0e1959fa24a8d3f55357779aeefb9e86148ff22fab3dda9663cd28f87b4a72d1\",\"dweb:/ipfs/QmdiGp59TPfxe48gXZ44fT6B9zPFgPn3y6iaA7zLsVsBrX\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"ZkSyncLiteSunsetClaimDistributor__InvalidProof()":[{"notice":"Thrown when the Merkle proof does not verify against `MERKLE_ROOT`."}],"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed()":[{"notice":"Thrown when the claim index has already been consumed."}],"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed()":[{"notice":"Thrown when the native-token transfer to the claimant reverts."}],"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen()":[{"notice":"Thrown when the claim window is not yet open."}]},"events":{"Claimed(uint256,address,address,uint256)":{"notice":"Emitted whenever a call to claim succeeds."}},"notice":"L1 distributor for the ZKsync Lite sunset. Funds committed in a Merkle tree can be claimed either by the claimant themselves or by any caller on behalf of the claimant; in both cases the funds are transferred to the claimant encoded in the leaf.","methods":{"pause()":{"notice":"Pauses all claim entrypoints."},"unpause()":{"notice":"Re-enables claim entrypoints."},"constructor":{"notice":"Disables initializers on the implementation so it can only be used behind a proxy."},"MERKLE_ROOT()":{"notice":"Merkle root over leaves `keccak256(abi.encodePacked(index, claimant, token, amount))`."},"WINDOW_START()":{"notice":"Claims are enabled at/after this timestamp."},"isClaimed(uint256)":{"notice":"Returns whether a claim index has already been consumed."},"initialize(bytes32,uint256,address)":{"notice":"Initializes proxy storage."},"claim(uint256,address,uint256,bytes32[])":{"notice":"Convenience self-claim path; equivalent to `claimTo` with `claimant = msg.sender`."},"claimTo(uint256,address,address,uint256,bytes32[])":{"notice":"Permissionless claim path; any caller can trigger the claim for `claimant`, and funds are transferred to `claimant` (as bound by the Merkle leaf)."}},"version":1},"devdoc":{"kind":"dev","title":"ZkSyncLiteSunsetClaimDistributorL1","author":"Matter Labs","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Initialized(uint8)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Claimed(uint256,address,address,uint256)":{"params":{"index":"The index of the claim leaf that was consumed.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount transferred to the claimant.","claimant":"The address encoded in the leaf and receiving the funds."}}},"details":"Leaf format is `keccak256(abi.encodePacked(index, claimant, token, amount))`. `token == address(0)` denotes a native ETH claim. Leaf indices must be globally unique across all leaves because the claimed bitmap is keyed only by `index`.Expected to be deployed as a TransparentUpgradeableProxy.","methods":{"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"Only the owner may pause; halts every claim path until `unpause` is called."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"unpause()":{"details":"Only the owner may unpause."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"isClaimed(uint256)":{"params":{"index":"The index of the claim leaf."},"returns":{"_0":"Whether the claim has been executed."}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"initialize(bytes32,uint256,address)":{"params":{"merkleRoot":"Merkle root for the claim dataset.","windowStart":"Claim start timestamp (inclusive).","initialOwner":"Owner allowed to pause and unpause claiming."},"details":"Transfers ownership to `initialOwner` if different from the proxy deployer that invokes this initializer."},"claim(uint256,address,uint256,bytes32[])":{"params":{"index":"The index of the claim leaf.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount to transfer.","merkleProof":"The Merkle proof for the claim leaf."}},"claimTo(uint256,address,address,uint256,bytes32[])":{"params":{"index":"The index of the claim leaf.","token":"The token address (use `address(0)` for native ETH).","amount":"The amount to transfer.","claimant":"The address encoded in the Merkle leaf and receiving the funds.","merkleProof":"The Merkle proof for the claim leaf."}}},"version":1,"custom:security-contact":"security@matterlabs.dev"},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint256)49_storage":{"base":"t_uint256","label":"uint256[49]","encoding":"inplace","numberOfBytes":"1568"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_struct(BitMap)1836_storage":{"label":"struct BitMapsUpgradeable.BitMap","members":[{"slot":"0","type":"t_mapping(t_uint256,t_uint256)","astId":1835,"label":"_data","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_uint256,t_uint256)":{"key":"t_uint256","label":"mapping(uint256 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":139,"label":"_initialized","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"0","type":"t_bool","astId":142,"label":"_initializing","offset":1,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":1299,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"51","type":"t_address","astId":11,"label":"_owner","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"52","type":"t_array(t_uint256)49_storage","astId":131,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"101","type":"t_bool","astId":323,"label":"_paused","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"102","type":"t_array(t_uint256)49_storage","astId":428,"label":"__gap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"151","type":"t_bytes32","astId":2000,"label":"MERKLE_ROOT","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"152","type":"t_uint256","astId":2003,"label":"WINDOW_START","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"},{"slot":"153","type":"t_struct(BitMap)1836_storage","astId":2007,"label":"claimedBitMap","offset":0,"contract":"src/ZkSyncLiteSunsetClaimDistributorL1.sol:ZkSyncLiteSunsetClaimDistributorL1"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"608080604052346100c1576000549060ff8260081c1661006f575060ff80821603610034575b604051610e5790816100c78239f35b60ff90811916176000557f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498602060405160ff8152a138610025565b62461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b6064820152608490fd5b600080fdfe60406080815260048036101561001f575b5050361561001d57600080fd5b005b600091823560e01c908163054d5e2a146107875781632e7ba6ef146104a857816337b82556146104895781633f4ba83a146103f257816351e75e8b146103d35781635c975abb146103af578163715018a6146103525781638456cb59146102f75781638da5cb5b146102ce5781639e34070f14610287578163c62b428e146100f6575063f2fde38b0361001057346100f25760203660031901126100f257356001600160a01b038116908181036100ee576100e66100eb926100df610be1565b1515610ad8565b610c39565b80f35b8280fd5b5080fd5b919050346100ee5760603660031901126100ee57610112610a91565b9083549160ff8360081c16159283809461027a575b8015610263575b156102095760ff19818116600117875590846101f8575b506001600160a01b0382169061015c821515610ad8565b61017560ff885460081c1661017081610c82565b610c82565b61017e33610c39565b61019260ff885460081c1661017081610c82565b6065541660655533036101e9575b50356097556024356098556101b3575080f35b60207f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989161ff001984541684555160018152a180f35b6101f290610c39565b386101a0565b61ffff191661010117865538610145565b845162461bcd60e51b8152602081850152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608490fd5b50303b15801561012e5750600160ff82161461012e565b50600160ff821610610127565b905082346102cb5760203660031901126102cb57506102c26020923560ff6001918060081c6000526099602052161b60406000205416151590565b90519015158152f35b80fd5b8390346100f257816003193601126100f25760335490516001600160a01b039091168152602090f35b8390346100f257816003193601126100f25760207f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a25891610335610be1565b61033d610b33565b600160ff19606554161760655551338152a180f35b83346102cb57806003193601126102cb5761036b610be1565b603380546001600160a01b0319811690915581906001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a380f35b8390346100f257816003193601126100f25760209060ff6065541690519015158152f35b8390346100f257816003193601126100f2576020906097549051908152f35b919050346100ee57826003193601126100ee5761040d610be1565b6065549060ff82161561044f575060ff1916606555513381527f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa90602090a180f35b606490602084519162461bcd60e51b8352820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b6044820152fd5b8390346100f257816003193601126100f2576020906098549051908152f35b919050346100ee5760803660031901126100ee578035916104c7610a76565b906044359260643567ffffffffffffffff8111610783576104eb9036908301610aa7565b6104f6929192610b33565b6098544210610774576105228760ff6001918060081c6000526099602052161b60406000205416151590565b6107655791835192602093848101908982523360601b8782015260018060a01b038816976bffffffffffffffffffffffff199060601b1660548201528860688201526068815261057181610b77565b5190209160975492918a915b81831061072e5750505003610720578560081c875260998252828720600160ff88161b81541790558315600014610600578680808088335af16105be610ce2565b50156105f257509160809391600080516020610e0283398151915295935b815194855233908501528301526060820152a180f35b825163c7a014b360e01b8152fd5b6106768351888085830163a9059cbb60e01b81523360248501528960448501526044845261062d84610ba9565b87519361063985610bc5565b8785527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564888601525190828a5af161066f610ce2565b9087610d2d565b80518381159182156106fc575b50509050156106a857509160809391600080516020610e0283398151915295936105dc565b915162461bcd60e51b815291820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608490fd5b838092935001031261071c57820151801515810361071c57808338610683565b8780fd5b8251639fa7b41b60e01b8152fd5b9091928360051b82013590818110600014610756578c5286526001878c205b9301919061057d565b908c5286526001878c2061074d565b508251634001cf0d60e11b8152fd5b508251637322611b60e01b8152fd5b8680fd5b9050346100ee5760a03660031901126100ee578135916107a5610a76565b916107ae610a91565b916064359360843567ffffffffffffffff811161071c576107d29036908401610aa7565b9290916107dd610b33565b6098544210610a67576108098860ff6001918060081c6000526099602052161b60406000205416151590565b610a58578451936020938a8587018b815260018060a01b0397888616986bffffffffffffffffffffffff1990818860601b168c8401528c169b60601b1660548201528b60688201526068815261085e81610b77565b51902092609754939289835b838510610a2457505050505003610a155788908860081c825260998452858220600160ff8b161b81541790558787156000146108f1578280929181925af16108b0610ce2565b50156108e3575091600080516020610e02833981519152959391608095935b82519586528501528301526060820152a180f35b835163c7a014b360e01b8152fd5b50505061096a8451898085830163a9059cbb60e01b81528760248501528a60448501526044845261092184610ba9565b88519361092d85610bc5565b8785527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564888601525190828b5af1610963610ce2565b9088610d2d565b80518381159182156109f1575b505090501561099d575091600080516020610e02833981519152959391608095936108cf565b60849184519162461bcd60e51b8352820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152fd5b8380929350010312610a11578201518015158103610a1157808338610977565b8880fd5b508351639fa7b41b60e01b8152fd5b8495600193949560051b85013590818110600014610a4d5782528a52205b93019190898e61086a565b9082528a5220610a42565b508351634001cf0d60e11b8152fd5b508351637322611b60e01b8152fd5b602435906001600160a01b0382168203610a8c57565b600080fd5b604435906001600160a01b0382168203610a8c57565b9181601f84011215610a8c5782359167ffffffffffffffff8311610a8c576020808501948460051b010111610a8c57565b15610adf57565b60405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608490fd5b60ff60655416610b3f57565b60405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b6044820152606490fd5b60a0810190811067ffffffffffffffff821117610b9357604052565b634e487b7160e01b600052604160045260246000fd5b6080810190811067ffffffffffffffff821117610b9357604052565b6040810190811067ffffffffffffffff821117610b9357604052565b6033546001600160a01b03163303610bf557565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b603380546001600160a01b039283166001600160a01b0319821681179092559091167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0600080a3565b15610c8957565b60405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b6064820152608490fd5b3d15610d285767ffffffffffffffff903d828111610b935760405192601f8201601f19908116603f0116840190811184821017610b935760405282523d6000602084013e565b606090565b91929015610d8f5750815115610d41575090565b3b15610d4a5790565b60405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606490fd5b825190915015610da25750805190602001fd5b6040519062461bcd60e51b82528160208060048301528251908160248401526000935b828510610de8575050604492506000838284010152601f80199101168101030190fd5b8481018201518686016044015293810193859350610dc556fece3bcb6e219596cf26007ffdfaae8953bc3f76e3f36c0a79b23e28020da3222ea264697066735822122025fb7b9bfd54b9b4544f97f93c8042c8a516f3379abe2bd3930f354f2736c62664736f6c63430008180033","sourceMap":"1535:7377:10:-:0;;;;;;;6007:13:1;1535:7377:10;;;;;;;;;;;;;;6078:31:1;6074:139;;-1:-1:-1;1535:7377:10;;;;;;;;;6074:139:1;1535:7377:10;;;;;;6007:13:1;1535:7377:10;6174:28:1;1535:7377:10;;;;;;6174:28:1;6074:139;;;1535:7377:10;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1535:7377:10:-:0;;;;;;;;;;;-1:-1:-1;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;;;2415:73:0;2517:8;1324:62;;;:::i;:::-;2423:22;;2415:73;:::i;:::-;2517:8;:::i;:::-;1535:7377:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;;3301:14:1;3347:34;;;;;;1535:7377:10;3346:108:1;;;;1535:7377:10;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;3562:65:1;;1535:7377:10;-1:-1:-1;;;;;;1535:7377:10;;;3786:77;3794:26;;;3786:77;:::i;:::-;5366:69:1;1535:7377:10;;;;;;5366:69:1;;;:::i;:::-;;:::i;:::-;1216:12:0;965:10:7;1216:12:0;:::i;:::-;5366:69:1;1535:7377:10;;;;;;5366:69:1;;;:::i;:::-;1260:15:2;1535:7377:10;;1260:15:2;1535:7377:10;965:10:7;3932:28:10;3928:91;;1535:7377;;;4029:24;1535:7377;;;4063:26;1535:7377;3647:99:1;;1535:7377:10;;;3647:99:1;1535:7377:10;3721:14:1;1535:7377:10;;;;;;;;;;;;3721:14:1;1535:7377:10;;3928:91;3995:12;;;:::i;:::-;3928:91;;;3562:65:1;-1:-1:-1;;1535:7377:10;;;;;3562:65:1;;;1535:7377:10;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;3346:108:1;3426:4;;1713:19:6;:23;3387:66:1;;3346:108;3387:66;1535:7377:10;;;;;3436:17:1;3346:108;;3347:34;1535:7377:10;;;;;3365:16:1;3347:34;;1535:7377:10;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;4356:24;1535:7377;;;;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;1534:6:0;1535:7377:10;;;-1:-1:-1;;;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;2538:20:2;1324:62:0;;;:::i;:::-;1468:72:2;;:::i;:::-;2519:4;1535:7377:10;;2509:14:2;1535:7377:10;;;2509:14:2;1535:7377:10;;965:10:7;1535:7377:10;;2538:20:2;1535:7377:10;;;;;;;;;;;;;;;1324:62:0;;:::i;:::-;2779:6;1535:7377:10;;-1:-1:-1;;;;;;1535:7377:10;;;;;;;-1:-1:-1;;;;;1535:7377:10;2827:40:0;1535:7377:10;;2827:40:0;1535:7377:10;;;;;;;;;;;;;;;;;;;1949:7:2;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;1861:26;1535:7377;;;;;;;;;;;;;;;;;;;;;;1324:62:0;;:::i;:::-;1949:7:2;1535:7377:10;;;;;;;;-1:-1:-1;;;1535:7377:10;1949:7:2;1535:7377:10;;965:10:7;1535:7377:10;;2785:22:2;;1535:7377:10;;2785:22:2;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;1953:27;1535:7377;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;1468:72:2;;;;;:::i;:::-;8552:12:10;1535:7377;8534:15;:30;8530:122;;4356:24;;1535:7377;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;8789:104;;1535:7377;;;;;7196:48;;;;1535:7377;;;;5471:10;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7196:48;;;;;:::i;:::-;1535:7377;7186:59;;1535:7377;7312:11;1535:7377;2454:27:8;2496:13;;2491:116;2511:16;;;;;;1546:41;;;;7256:156:10;;1535:7377;1228:1:9;1535:7377:10;;;4356:13;1535:7377;;;;;;;1260:12:9;;1535:7377:10;;;1283:28:9;1535:7377:10;;8121:19;;8117:306;1535:7377;;;5471:10;;;;;;8174:32;;;;:::i;:::-;;8224:8;8220:107;;8117:306;;1535:7377;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;;;;;5471:10;1535:7377;;;;;;;;;;;7510:39;1535:7377;;8220:107;1535:7377;;-1:-1:-1;;;8259:53:10;;;8117:306;5546:69:6;1535:7377:10;;1116:58:5;;;;;1535:7377:10;;;1116:58:5;;5471:10:10;1535:7377;1116:58:5;;1535:7377:10;;;;;;;1116:58:5;;;;;:::i;:::-;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;5498:31:6;;;;;;;;:::i;:::-;5546:69;;;:::i;:::-;1535:7377:10;;5871:22:5;;;:56;;;;;8117:306:10;1535:7377;;;;;;;8117:306;;1535:7377;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;;1535:7377;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;5871:56:5;5897:30;;;;;;1535:7377:10;;;;5897:30:5;;1535:7377:10;;;;;;;;5871:56:5;;;;;1535:7377:10;;;;7256:156;1535:7377;;-1:-1:-1;;;7353:48:10;;;2529:3:8;1535:7377:10;;;;;;;;;9305:51:8;:5;;;:51;:5;;;9505:119;;;;1535:7377:10;9505:119:8;;;9305:51;2529:3;1535:7377:10;2496:13:8;;;;9305:51;9505:119;;;;;1535:7377:10;9505:119:8;;;9305:51;;8789:104:10;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8832:50:10;;;8530:122;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8587:54:10;;;1535:7377;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;1468:72:2;;;;;:::i;:::-;8552:12:10;1535:7377;8534:15;:30;8530:122;;4356:24;;1535:7377;721:1:9;579:217;1535:7377:10;695:1:9;1535:7377:10;-1:-1:-1;1535:7377:10;4356:13;1535:7377;;727:12:9;1535:7377:10;;-1:-1:-1;1535:7377:10;;757:27:9;:32;;579:217;;4356:24:10;8789:104;;1535:7377;;;;7196:48;;;;;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7196:48;;;;;:::i;:::-;1535:7377;7186:59;;1535:7377;7312:11;1535:7377;2454:27:8;2496:13;;;2511:16;;;;;;1546:41;;;;;;7256:156:10;;1535:7377;;;1228:1:9;1535:7377:10;;;4356:13;1535:7377;;;;;;;1260:12:9;;1535:7377:10;;;1283:28:9;1535:7377:10;;8121:19;;;8117:306;1535:7377;;;8174:32;;;;;;;;;;:::i;:::-;;8224:8;8220:107;;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;8117:306;;;1535:7377;;;;;;;;;;;;;;;7510:39;1535:7377;;8220:107;1535:7377;;-1:-1:-1;;;8259:53:10;;;8117:306;1535:7377;;;5546:69:6;1535:7377:10;;1116:58:5;;;;;1535:7377:10;;;1116:58:5;;;1535:7377:10;1116:58:5;;1535:7377:10;;;;;;;1116:58:5;;;;;:::i;:::-;1535:7377:10;;;;;;:::i;:::-;;;;;;;;;5498:31:6;;;;;;;;:::i;:::-;5546:69;;;:::i;:::-;1535:7377:10;;5871:22:5;;;:56;;;;;8117:306:10;1535:7377;;;;;;;8117:306;;-1:-1:-1;;;;;;;;;;;8117:306:10;;;1535:7377;8117:306;;;;1535:7377;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;5871:56:5;5897:30;;;;;;1535:7377:10;;;;5897:30:5;;1535:7377:10;;;;;;;;5871:56:5;;;;;1535:7377:10;;;;7256:156;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;7353:48:10;;;2529:3:8;1535:7377:10;;;;;;;;;;;9305:51:8;:5;;;:51;:5;;;9505:119;;;;;9305:51;2529:3;1535:7377:10;2496:13:8;;;;;;9305:51;9505:119;;;;;;9305:51;;8789:104:10;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8832:50:10;;;8530:122;-1:-1:-1;1535:7377:10;;-1:-1:-1;;;8587:54:10;;;1535:7377;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;1535:7377:10;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;2031:106:2;1535:7377:10;1949:7:2;1535:7377:10;;;;2031:106:2:o;1535:7377:10:-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;1620:130:0:-;1534:6;1535:7377:10;-1:-1:-1;;;;;1535:7377:10;965:10:7;1683:23:0;1535:7377:10;;1620:130:0:o;1535:7377:10:-;;;;;;;;;;;;;;;;;;;;;;;;;2687:187:0;2779:6;1535:7377:10;;-1:-1:-1;;;;;1535:7377:10;;;-1:-1:-1;;;;;;1535:7377:10;;;;;;;;;;2827:40:0;-1:-1:-1;;2827:40:0;2687:187::o;1535:7377:10:-;;;;:::o;:::-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1535:7377:10;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1535:7377:10;;;;:::o;:::-;;;:::o;7682:628:6:-;;;;7886:418;;;1535:7377:10;;;7917:22:6;7913:286;;8212:17;;:::o;7913:286::-;1713:19;:23;1535:7377:10;;8212:17:6;:::o;1535:7377:10:-;;;-1:-1:-1;;;1535:7377:10;;;;;;;;;;;;;;;;;;;;7886:418:6;1535:7377:10;;;;-1:-1:-1;8991:21:6;:17;;9163:142;;;;;;;8987:379;1535:7377:10;;;;;;9335:20:6;;1535:7377:10;;;9335:20:6;;;1535:7377:10;;;;;;;;;9011:1:6;1535:7377:10;;;;;;;;;;;;9011:1:6;1535:7377:10;;;;;;;;;;;;;;9335:20:6;;;;1535:7377:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;1535:7377:10;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"claimTo(uint256,address,address,uint256,bytes32[])","signatureHash4":"0x054d5e2a","signatureHash32":"0x054d5e2ae6a3bb97e23ff5999eb97ade0747f17c9007ac826906cc87f1239eb0"},{"signature":"claim(uint256,address,uint256,bytes32[])","signatureHash4":"0x2e7ba6ef","signatureHash32":"0x2e7ba6ef57e4cef2097ba4303e22a98d638fc6e10aac5306f89dc87d94f3cc14"},{"signature":"initialize(bytes32,uint256,address)","signatureHash4":"0xc62b428e","signatureHash32":"0xc62b428e62420c606beb98c15d5f33941994c888dcd65b04976040586c30b9d7"},{"signature":"isClaimed(uint256)","signatureHash4":"0x9e34070f","signatureHash32":"0x9e34070fac031304f0d6e35d8cfd277768530d455f46c76539c242588349a19f"},{"signature":"MERKLE_ROOT()","signatureHash4":"0x51e75e8b","signatureHash32":"0x51e75e8bb8cd0c663ad134cf310f0f901086ba647c0d84e5c8be26099b47a90f"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"pause()","signatureHash4":"0x8456cb59","signatureHash32":"0x8456cb591a934d53f6ccc6332123a165a1f3562907bf11330d847a29ca49eb89"},{"signature":"paused()","signatureHash4":"0x5c975abb","signatureHash32":"0x5c975abbf8c4d6efa68fc896e233763eb503f2318260b7bf59b19412913788b2"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unpause()","signatureHash4":"0x3f4ba83a","signatureHash32":"0x3f4ba83af89dc9793996d9e56b8abe6dc88cd97c9c2bb23027806e9c1ffd54dc"},{"signature":"WINDOW_START()","signatureHash4":"0x37b82556","signatureHash32":"0x37b825563ccc20903581e293aaa6c81fc8300a2becbc50abbe651a0e425e32a6"}],"event":[{"signature":"Claimed(uint256,address,address,uint256)","signatureHash4":"0xce3bcb6e","signatureHash32":"0xce3bcb6e219596cf26007ffdfaae8953bc3f76e3f36c0a79b23e28020da3222e"},{"signature":"Initialized(uint8)","signatureHash4":"0x7f26b83f","signatureHash32":"0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Paused(address)","signatureHash4":"0x62e78cea","signatureHash32":"0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258"},{"signature":"Unpaused(address)","signatureHash4":"0x5db9ee0a","signatureHash32":"0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa"}],"error":[{"signature":"ZkSyncLiteSunsetClaimDistributor__AlreadyClaimed()","signatureHash4":"0x80039e1a","signatureHash32":"0x80039e1afdadf9b3772a257b2fd8ac25701aba570a458eab80e6f60f11afa863"},{"signature":"ZkSyncLiteSunsetClaimDistributor__ClaimWindowNotOpen()","signatureHash4":"0x7322611b","signatureHash32":"0x7322611b24981c37b36b013484b5e3f383b9c606ac09adddf6631b0e95d6152e"},{"signature":"ZkSyncLiteSunsetClaimDistributor__EthTransferFailed()","signatureHash4":"0xc7a014b3","signatureHash32":"0xc7a014b3599c44f20bf57d23f1790362534aed43fcbfd5a792b24c17d50bc5f2"},{"signature":"ZkSyncLiteSunsetClaimDistributor__InvalidProof()","signatureHash4":"0x9fa7b41b","signatureHash32":"0x9fa7b41badfb2d4e6d64403511b8ee8dfa71cb2b66466a65574e6b8dd63667b9"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0xfB94f8a45E81fa9f6256Ddb0EEc0735b8520CdeA"}