From ece167d8dd475477e0f8576d213c09f8b8748174 Mon Sep 17 00:00:00 2001 From: CounterFire2023 <136581895+CounterFire2023@users.noreply.github.com> Date: Thu, 27 Jun 2024 17:09:07 +0800 Subject: [PATCH] update contract for mint2 --- build/contracts/NFTClaimStage2WL.json | 56 +++++++- contracts/activity/NFTClaimStage2WL.sol | 19 ++- contracts/tools/AirdropToken.sol | 43 ++++++ deploy/5_deploy_airdrop.ts | 27 ++++ deployments/imtbl_test/NFTClaimStage2WL.json | 128 ++++++++++++++---- ... => 7a21470cd04b53fd0b413c61220c019c.json} | 2 +- out/imtbl_test_dev.json | 8 +- package.json | 1 + 8 files changed, 247 insertions(+), 37 deletions(-) create mode 100644 contracts/tools/AirdropToken.sol create mode 100644 deploy/5_deploy_airdrop.ts rename deployments/imtbl_test/solcInputs/{51bc58a876e88f27d12eca799d1f4f63.json => 7a21470cd04b53fd0b413c61220c019c.json} (94%) diff --git a/build/contracts/NFTClaimStage2WL.json b/build/contracts/NFTClaimStage2WL.json index 8d7eb75..f208067 100644 --- a/build/contracts/NFTClaimStage2WL.json +++ b/build/contracts/NFTClaimStage2WL.json @@ -91,6 +91,19 @@ "name": "MintConfigUpdated", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_nft", + "type": "address" + } + ], + "name": "NFTAddressUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -116,6 +129,19 @@ "name": "NFTClaimed", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "_nftIdStart", + "type": "uint256" + } + ], + "name": "NFTIdStartUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -615,10 +641,36 @@ "outputs": [], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_nft", + "type": "address" + } + ], + "name": "updateNftAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_nftIdStart", + "type": "uint256" + } + ], + "name": "updateNftIdStart", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "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", + "deployedBytecode": "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", "linkReferences": {}, "deployedLinkReferences": {} } diff --git a/contracts/activity/NFTClaimStage2WL.sol b/contracts/activity/NFTClaimStage2WL.sol index 6580552..7f4779c 100644 --- a/contracts/activity/NFTClaimStage2WL.sol +++ b/contracts/activity/NFTClaimStage2WL.sol @@ -30,8 +30,8 @@ contract NFTClaimStage2WL is ReentrancyGuard, AccessControl { } // parse: 0: not open or end, 1: phase1, 2: phase2 uint256 public mintParse = 0; - address public immutable nftAddress; - uint256 public immutable nftIdStart; + address public nftAddress; + uint256 public nftIdStart; MintConfig public mintConfig; uint256 public totalCount; @@ -44,6 +44,8 @@ contract NFTClaimStage2WL is ReentrancyGuard, AccessControl { event ParseUpdated(uint256 _parse); event MintConfigUpdated(MintConfig config); + event NFTAddressUpdated(address _nft); + event NFTIdStartUpdated(uint256 _nftIdStart); constructor(address _nftAddress, uint256 _nftIdStart, MintConfig memory _mintConfig) { _grantRole(DEFAULT_ADMIN_ROLE, _msgSender()); @@ -95,6 +97,17 @@ contract NFTClaimStage2WL is ReentrancyGuard, AccessControl { } } + function updateNftAddress(address _nft) external onlyRole(MANAGE_ROLE) { + require(_nft != address(0), "NFTClaimer: invalid nft address"); + nftAddress = _nft; + emit NFTAddressUpdated(_nft); + } + + function updateNftIdStart(uint256 _nftIdStart) external onlyRole(MANAGE_ROLE) { + nftIdStart = _nftIdStart; + emit NFTIdStartUpdated(_nftIdStart); + } + /** * @dev claim NFT @@ -113,7 +126,6 @@ contract NFTClaimStage2WL is ReentrancyGuard, AccessControl { require(_whitelist1[to] + _whitelist2[to] >= _mintedCount + nftCount, "NFTClaimer: not in whitelist or exceed limit"); } uint256 _tokenAmount = mintConfig.mintPrice * nftCount; - totalCount += nftCount; IERC20(mintConfig.currency).safeTransferFrom(to, mintConfig.feeToAddress, _tokenAmount); uint256[] memory ids = new uint256[](nftCount); for (uint256 i = 0; i < nftCount; ++i) { @@ -122,6 +134,7 @@ contract NFTClaimStage2WL is ReentrancyGuard, AccessControl { _mintedRecords[to].add(_nftId); IClaimAbleNFT(nftAddress).safeMint(to, _nftId); } + totalCount += nftCount; emit NFTClaimed(nftAddress, to, ids); } diff --git a/contracts/tools/AirdropToken.sol b/contracts/tools/AirdropToken.sol new file mode 100644 index 0000000..5eb6007 --- /dev/null +++ b/contracts/tools/AirdropToken.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.19; + +import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol"; +import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +contract AirdropToken { + using SafeERC20 for IERC20; + mapping(address user => uint256 amount) public failTransferList; + + function getSum(uint256[] calldata _arr) public pure returns (uint256 sum) { + for (uint256 i = 0; i < _arr.length; i++) sum = sum + _arr[i]; + } + + function multiTransferETH(address payable[] calldata _addresses, uint256[] calldata _amounts) public payable { + require(_addresses.length == _amounts.length, "Lengths of Addresses and Amounts NOT EQUAL"); + uint256 _amountSum = getSum(_amounts); + require(msg.value == _amountSum, "Transfer amount error"); + for (uint256 i = 0; i < _addresses.length; i++) { + (bool success, ) = _addresses[i].call{value: _amounts[i]}(""); + if (!success) { + failTransferList[_addresses[i]] = _amounts[i]; + } + } + } + + function multiTransferERC20(address _token, address[] calldata _addresses, uint256[] calldata _amounts) external { + require(_addresses.length == _amounts.length, "Lengths of Addresses and Amounts NOT EQUAL"); + IERC20 token = IERC20(_token); + for (uint256 i; i < _addresses.length; i++) { + token.safeTransferFrom(msg.sender, _addresses[i], _amounts[i]); + } + } + + function multiTransferERC721(address _token, address[] calldata _addresses, uint256[] calldata _tokenIds) external { + require(_addresses.length == _tokenIds.length, "Lengths of Addresses and TokenIds NOT EQUAL"); + IERC721 token = IERC721(_token); + for (uint256 i; i < _addresses.length; i++) { + token.transferFrom(msg.sender, _addresses[i], _tokenIds[i]); + } + } +} diff --git a/deploy/5_deploy_airdrop.ts b/deploy/5_deploy_airdrop.ts new file mode 100644 index 0000000..eb3f738 --- /dev/null +++ b/deploy/5_deploy_airdrop.ts @@ -0,0 +1,27 @@ +import { HardhatRuntimeEnvironment } from "hardhat/types"; +import { DeployFunction } from "hardhat-deploy/types"; +import { updateArray } from "../scripts/utils" + + +const deployNFTClaim: DeployFunction = + async function (hre: HardhatRuntimeEnvironment) { + const provider = hre.ethers.provider; + const from = await (await provider.getSigner()).getAddress(); + const ret = await hre.deployments.deploy("AirdropToken", { + from, + args: [], + log: true, + }); + console.log("==AirdropToken addr=", ret.address); + updateArray({ + name: "AirdropToken", + type: "logic", + json: "assets/contracts/AirdropToken.json", + address: ret.address, + network: hre.network.name, + }); + }; + + deployNFTClaim.tags = ["AirdropToken"]; + +export default deployNFTClaim; diff --git a/deployments/imtbl_test/NFTClaimStage2WL.json b/deployments/imtbl_test/NFTClaimStage2WL.json index fcd7dfe..4d37a80 100644 --- a/deployments/imtbl_test/NFTClaimStage2WL.json +++ b/deployments/imtbl_test/NFTClaimStage2WL.json @@ -1,5 +1,5 @@ { - "address": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e", + "address": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a", "abi": [ { "inputs": [ @@ -89,6 +89,19 @@ "name": "MintConfigUpdated", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_nft", + "type": "address" + } + ], + "name": "NFTAddressUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -114,6 +127,19 @@ "name": "NFTClaimed", "type": "event" }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "_nftIdStart", + "type": "uint256" + } + ], + "name": "NFTIdStartUpdated", + "type": "event" + }, { "anonymous": false, "inputs": [ @@ -613,24 +639,50 @@ "outputs": [], "stateMutability": "nonpayable", "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_nft", + "type": "address" + } + ], + "name": "updateNftAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_nftIdStart", + "type": "uint256" + } + ], + "name": "updateNftIdStart", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" } ], - "transactionHash": "0x281796d472c741fd679003f10583289724f762a6c05470247b4823ea8f36287c", + "transactionHash": "0xc3448f5fd4a908441c16c7836d7986fa9680ae6e4d25d5365b1f3a150b1e5798", "receipt": { "to": null, "from": "0x50A8e60041A206AcaA5F844a1104896224be6F39", - "contractAddress": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e", + "contractAddress": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a", "transactionIndex": 0, - "gasUsed": "1618199", - "logsBloom": "0x00000004000000000000000000000000000000000140020000000000000820000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000200000000000000800000000000000400000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000180000000400020000000000000000000000000000000000000020000000000000000000000000000", - "blockHash": "0x6ae3635d204428dac3f2a8c573f691505a1b8a903a6e9a9fa4d9e913fcdcc08b", - "transactionHash": "0x281796d472c741fd679003f10583289724f762a6c05470247b4823ea8f36287c", + "gasUsed": "1702816", + "logsBloom": "0x00000004000000000000000000000000000000000000020000000000000820000000000000000000000000000000100000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000020000000000000000000800000000000000400000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000800000000004000000000000000000000000000000000000000000180000000400020000000000000000000000000000000000000020000000000000000000000000000", + "blockHash": "0x5b96d2779395584f0a3c3a65f113d60802bb98c05bb44b22e0fb76354e14ceef", + "transactionHash": "0xc3448f5fd4a908441c16c7836d7986fa9680ae6e4d25d5365b1f3a150b1e5798", "logs": [ { "transactionIndex": 0, - "blockNumber": 10233694, - "transactionHash": "0x281796d472c741fd679003f10583289724f762a6c05470247b4823ea8f36287c", - "address": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e", + "blockNumber": 10244276, + "transactionHash": "0xc3448f5fd4a908441c16c7836d7986fa9680ae6e4d25d5365b1f3a150b1e5798", + "address": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a", "topics": [ "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -639,13 +691,13 @@ ], "data": "0x", "logIndex": 0, - "blockHash": "0x6ae3635d204428dac3f2a8c573f691505a1b8a903a6e9a9fa4d9e913fcdcc08b" + "blockHash": "0x5b96d2779395584f0a3c3a65f113d60802bb98c05bb44b22e0fb76354e14ceef" }, { "transactionIndex": 0, - "blockNumber": 10233694, - "transactionHash": "0x281796d472c741fd679003f10583289724f762a6c05470247b4823ea8f36287c", - "address": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e", + "blockNumber": 10244276, + "transactionHash": "0xc3448f5fd4a908441c16c7836d7986fa9680ae6e4d25d5365b1f3a150b1e5798", + "address": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a", "topics": [ "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", "0x5550444154455f574c5f524f4c45000000000000000000000000000000000000", @@ -654,13 +706,13 @@ ], "data": "0x", "logIndex": 1, - "blockHash": "0x6ae3635d204428dac3f2a8c573f691505a1b8a903a6e9a9fa4d9e913fcdcc08b" + "blockHash": "0x5b96d2779395584f0a3c3a65f113d60802bb98c05bb44b22e0fb76354e14ceef" }, { "transactionIndex": 0, - "blockNumber": 10233694, - "transactionHash": "0x281796d472c741fd679003f10583289724f762a6c05470247b4823ea8f36287c", - "address": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e", + "blockNumber": 10244276, + "transactionHash": "0xc3448f5fd4a908441c16c7836d7986fa9680ae6e4d25d5365b1f3a150b1e5798", + "address": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a", "topics": [ "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d", "0xa076a07f65bcd51bcb15a0f01a65bc18f2d922acb81bcfd8af4caf5adb557091", @@ -669,11 +721,11 @@ ], "data": "0x", "logIndex": 2, - "blockHash": "0x6ae3635d204428dac3f2a8c573f691505a1b8a903a6e9a9fa4d9e913fcdcc08b" + "blockHash": "0x5b96d2779395584f0a3c3a65f113d60802bb98c05bb44b22e0fb76354e14ceef" } ], - "blockNumber": 10233694, - "cumulativeGasUsed": "1618199", + "blockNumber": 10244276, + "cumulativeGasUsed": "1702816", "status": 1, "byzantium": true }, @@ -689,10 +741,10 @@ ] ], "numDeployments": 1, - "solcInputHash": "51bc58a876e88f27d12eca799d1f4f63", - "metadata": "{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_nftAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_nftIdStart\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"_mintConfig\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"MintConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"nftAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"NFTClaimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_parse\",\"type\":\"uint256\"}],\"name\":\"ParseUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MANAGE_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPDATE_WL_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_nums\",\"type\":\"uint256[]\"}],\"name\":\"addParse1WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"addParse2WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"nftCount\",\"type\":\"uint256\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintConfig\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintParse\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintedNft\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintedNum\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nftAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nftIdStart\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"queryInfo\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"num1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"num2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minted\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"revokeParse1WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"revokeParse2WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"updateMintConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_mintParse\",\"type\":\"uint256\"}],\"name\":\"updateMintParse\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"RoleAdminChanged(bytes32,bytes32,bytes32)\":{\"details\":\"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._\"},\"RoleGranted(bytes32,address,address)\":{\"details\":\"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}.\"},\"RoleRevoked(bytes32,address,address)\":{\"details\":\"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call: - if using `revokeRole`, it is the admin role bearer - if using `renounceRole`, it is the role bearer (i.e. `account`)\"}},\"kind\":\"dev\",\"methods\":{\"claim(uint256)\":{\"details\":\"claim NFT\",\"params\":{\"nftCount\":\"nft count to claim\"}},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"MANAGE_ROLE()\":{\"notice\":\"Only MANAGE_ROLE can change mint config\"},\"UPDATE_WL_ROLE()\":{\"notice\":\"Only UPDATE_WL_ROLE can add white listing\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/activity/NFTClaimStage2WL.sol\":\"NFTClaimStage2WL\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/access/AccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAccessControl.sol\\\";\\nimport \\\"../utils/Context.sol\\\";\\nimport \\\"../utils/Strings.sol\\\";\\nimport \\\"../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```solidity\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```solidity\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\\n * to enforce additional security measures for this role.\\n */\\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\\n struct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role);\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `_msgSender()` is missing `role`.\\n * Overriding this function changes the behavior of the {onlyRole} modifier.\\n *\\n * Format of the revert message is described in {_checkRole}.\\n *\\n * _Available since v4.6._\\n */\\n function _checkRole(bytes32 role) internal view virtual {\\n _checkRole(role, _msgSender());\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view virtual {\\n if (!hasRole(role, account)) {\\n revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n Strings.toHexString(account),\\n \\\" is missing role \\\",\\n Strings.toHexString(uint256(role), 32)\\n )\\n )\\n );\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * May emit a {RoleGranted} event.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n *\\n * NOTE: This function is deprecated in favor of {_grantRole}.\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n bytes32 previousAdminRole = getRoleAdmin(role);\\n _roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function _grantRole(bytes32 role, address account) internal virtual {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function _revokeRole(bytes32 role, address account) internal virtual {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dd6e52cb394d7f5abe5dca2d4908a6be40417914720932de757de34a99ab87f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/security/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xa535a5df777d44e945dd24aa43a11e44b024140fc340ad0dfe42acf4002aade1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/IERC20Permit.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20Permit token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n function _contextSuffixLength() internal view virtual returns (uint256) {\\n return 0;\\n }\\n}\\n\",\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math.sol\\\";\\nimport \\\"./math/SignedMath.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n */\\n function toString(int256 value) internal pure returns (string memory) {\\n return string(abi.encodePacked(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMath.abs(value))));\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n }\\n\\n /**\\n * @dev Returns true if the two strings are equal.\\n */\\n function equal(string memory a, string memory b) internal pure returns (bool) {\\n return keccak256(bytes(a)) == keccak256(bytes(b));\\n }\\n}\\n\",\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n // The surrounding unchecked block does not change this fact.\\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1, \\\"Math: mulDiv overflow\\\");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10 ** 64) {\\n value /= 10 ** 64;\\n result += 64;\\n }\\n if (value >= 10 ** 32) {\\n value /= 10 ** 32;\\n result += 32;\\n }\\n if (value >= 10 ** 16) {\\n value /= 10 ** 16;\\n result += 16;\\n }\\n if (value >= 10 ** 8) {\\n value /= 10 ** 8;\\n result += 8;\\n }\\n if (value >= 10 ** 4) {\\n value /= 10 ** 4;\\n result += 4;\\n }\\n if (value >= 10 ** 2) {\\n value /= 10 ** 2;\\n result += 2;\\n }\\n if (value >= 10 ** 1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMath {\\n /**\\n * @dev Returns the largest of two signed numbers.\\n */\\n function max(int256 a, int256 b) internal pure returns (int256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two signed numbers.\\n */\\n function min(int256 a, int256 b) internal pure returns (int256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two signed numbers without overflow.\\n * The result is rounded towards zero.\\n */\\n function average(int256 a, int256 b) internal pure returns (int256) {\\n // Formula from the book \\\"Hacker's Delight\\\"\\n int256 x = (a & b) + ((a ^ b) >> 1);\\n return x + (int256(uint256(x) >> 255) & (a ^ b));\\n }\\n\\n /**\\n * @dev Returns the absolute unsigned value of a signed value.\\n */\\n function abs(int256 n) internal pure returns (uint256) {\\n unchecked {\\n // must be unchecked in order to support `n = type(int256).min`\\n return uint256(n >= 0 ? n : -n);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)\\n// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```solidity\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n *\\n * [WARNING]\\n * ====\\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\\n * unusable.\\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\\n *\\n * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an\\n * array of EnumerableSet.\\n * ====\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping(bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) {\\n // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n if (lastIndex != toDeleteIndex) {\\n bytes32 lastValue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastValue;\\n // Update the index for the moved value\\n set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex\\n }\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n return set._values[index];\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function _values(Set storage set) private view returns (bytes32[] memory) {\\n return set._values;\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n bytes32[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(AddressSet storage set) internal view returns (address[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n address[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(UintSet storage set) internal view returns (uint256[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n uint256[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n}\\n\",\"keccak256\":\"0x9f4357008a8f7d8c8bf5d48902e789637538d8c016be5766610901b4bba81514\",\"license\":\"MIT\"},\"contracts/activity/NFTClaimStage2WL.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.19;\\n\\nimport {ReentrancyGuard} from \\\"@openzeppelin/contracts/security/ReentrancyGuard.sol\\\";\\nimport {IERC20} from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport {AccessControl} from \\\"@openzeppelin/contracts/access/AccessControl.sol\\\";\\nimport {EnumerableSet} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport {SafeERC20} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n/**\\n * Contract for the activity of NFT claim stage 2.\\n */\\ninterface IClaimAbleNFT {\\n function safeMint(address to, uint256 tokenID) external;\\n}\\n\\ncontract NFTClaimStage2WL is ReentrancyGuard, AccessControl {\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeERC20 for IERC20;\\n /// @notice Only UPDATE_WL_ROLE can add white listing\\n bytes32 public constant UPDATE_WL_ROLE = bytes32(\\\"UPDATE_WL_ROLE\\\");\\n /// @notice Only MANAGE_ROLE can change mint config\\n bytes32 public constant MANAGE_ROLE = keccak256(\\\"MANAGE_ROLE\\\");\\n\\n struct MintConfig {\\n uint256 maxSupply; // max supply for phase2\\n address currency; // token address which user must pay to mint\\n uint256 mintPrice; // in wei\\n address feeToAddress; // wallet address to receive mint fee\\n uint256 airdropCount; // airdrop count\\n }\\n // parse: 0: not open or end, 1: phase1, 2: phase2\\n uint256 public mintParse = 0;\\n address public immutable nftAddress;\\n uint256 public immutable nftIdStart;\\n\\n MintConfig public mintConfig;\\n uint256 public totalCount;\\n mapping(address user => uint256 num) private _whitelist1;\\n mapping(address user => uint256 num) private _whitelist2;\\n mapping(address user => EnumerableSet.UintSet tokenIdSet) private _mintedRecords;\\n \\n\\n event NFTClaimed(address indexed nftAddress, address indexed to, uint256[] ids);\\n\\n event ParseUpdated(uint256 _parse);\\n event MintConfigUpdated(MintConfig config);\\n\\n constructor(address _nftAddress, uint256 _nftIdStart, MintConfig memory _mintConfig) {\\n _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());\\n _grantRole(UPDATE_WL_ROLE, _msgSender());\\n _grantRole(MANAGE_ROLE, _msgSender());\\n nftAddress = _nftAddress;\\n mintConfig = _mintConfig;\\n nftIdStart = _nftIdStart;\\n }\\n\\n modifier whenNotPaused() {\\n require(mintParse > 0, \\\"NFTClaimer: not begin or ended\\\");\\n _;\\n }\\n\\n function updateMintParse(uint256 _mintParse) external onlyRole(MANAGE_ROLE) {\\n require(_mintParse == 0 || _mintParse == 1 || _mintParse == 2, \\\"NFTClaimer: invalid mintParse\\\");\\n mintParse = _mintParse;\\n emit ParseUpdated(_mintParse);\\n }\\n\\n function updateMintConfig(MintConfig calldata config) external onlyRole(MANAGE_ROLE) {\\n mintConfig = config;\\n emit MintConfigUpdated(config);\\n }\\n\\n function addParse1WL(address[] calldata _addressList, uint256[] calldata _nums) external onlyRole(UPDATE_WL_ROLE) {\\n require(_addressList.length == _nums.length, \\\"NFTClaimer: invalid whitelist\\\");\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n _whitelist1[_addressList[i]] = _nums[i];\\n }\\n }\\n\\n function revokeParse1WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n delete _whitelist1[_addressList[i]];\\n }\\n }\\n\\n function addParse2WL(address[] calldata _addressList) external onlyRole(UPDATE_WL_ROLE){\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n _whitelist2[_addressList[i]] = 1;\\n }\\n }\\n\\n function revokeParse2WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n delete _whitelist2[_addressList[i]];\\n }\\n }\\n\\n\\n /**\\n * @dev claim NFT\\n * @param nftCount nft count to claim\\n */\\n function claim(\\n uint256 nftCount\\n ) external nonReentrant whenNotPaused {\\n require(nftCount > 0, \\\"NFTClaimer: nft count must be greater than 0\\\");\\n require(nftCount <= mintConfig.maxSupply - mintConfig.airdropCount - totalCount, \\\"NFTClaimer: exceed max supply\\\");\\n address to = _msgSender();\\n uint256 _mintedCount = _mintedRecords[to].length();\\n if (mintParse == 1) {\\n require(_whitelist1[to] >= _mintedCount + nftCount, \\\"NFTClaimer: not in whitelist or exceed limit\\\");\\n } else if (mintParse == 2) {\\n require(_whitelist1[to] + _whitelist2[to] >= _mintedCount + nftCount, \\\"NFTClaimer: not in whitelist or exceed limit\\\");\\n }\\n uint256 _tokenAmount = mintConfig.mintPrice * nftCount;\\n totalCount += nftCount;\\n IERC20(mintConfig.currency).safeTransferFrom(to, mintConfig.feeToAddress, _tokenAmount);\\n uint256[] memory ids = new uint256[](nftCount);\\n for (uint256 i = 0; i < nftCount; ++i) {\\n uint256 _nftId = nftIdStart + totalCount + i;\\n ids[i] = _nftId;\\n _mintedRecords[to].add(_nftId);\\n IClaimAbleNFT(nftAddress).safeMint(to, _nftId);\\n }\\n emit NFTClaimed(nftAddress, to, ids);\\n }\\n\\n function queryInfo() external view returns (uint256 num1, uint256 num2, uint256 minted) {\\n num1 = _whitelist1[_msgSender()];\\n num2 = _whitelist2[_msgSender()];\\n minted = _mintedRecords[_msgSender()].length();\\n return (num1, num2, minted);\\n }\\n\\n\\n function mintedNum() external view returns (uint256){\\n return _mintedRecords[_msgSender()].length();\\n }\\n\\n function mintedNft() external view returns (uint256[] memory){\\n return _mintedRecords[_msgSender()].values();\\n }\\n\\n}\\n\",\"keccak256\":\"0x182b77a691b7c793d6d2b8f239157d4d5d2572bc7454ba1cb4602e12ca29ce7d\",\"license\":\"MIT\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", + "solcInputHash": "7a21470cd04b53fd0b413c61220c019c", + "metadata": "{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_nftAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_nftIdStart\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"_mintConfig\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"MintConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_nft\",\"type\":\"address\"}],\"name\":\"NFTAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"nftAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"NFTClaimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_nftIdStart\",\"type\":\"uint256\"}],\"name\":\"NFTIdStartUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_parse\",\"type\":\"uint256\"}],\"name\":\"ParseUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MANAGE_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPDATE_WL_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_nums\",\"type\":\"uint256[]\"}],\"name\":\"addParse1WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"addParse2WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"nftCount\",\"type\":\"uint256\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintConfig\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintParse\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintedNft\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"mintedNum\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nftAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nftIdStart\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"queryInfo\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"num1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"num2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minted\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"revokeParse1WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_addressList\",\"type\":\"address[]\"}],\"name\":\"revokeParse2WL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"maxSupply\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"currency\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"mintPrice\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeToAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"airdropCount\",\"type\":\"uint256\"}],\"internalType\":\"struct NFTClaimStage2WL.MintConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"updateMintConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_mintParse\",\"type\":\"uint256\"}],\"name\":\"updateMintParse\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_nft\",\"type\":\"address\"}],\"name\":\"updateNftAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_nftIdStart\",\"type\":\"uint256\"}],\"name\":\"updateNftIdStart\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"RoleAdminChanged(bytes32,bytes32,bytes32)\":{\"details\":\"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._\"},\"RoleGranted(bytes32,address,address)\":{\"details\":\"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}.\"},\"RoleRevoked(bytes32,address,address)\":{\"details\":\"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call: - if using `revokeRole`, it is the admin role bearer - if using `renounceRole`, it is the role bearer (i.e. `account`)\"}},\"kind\":\"dev\",\"methods\":{\"claim(uint256)\":{\"details\":\"claim NFT\",\"params\":{\"nftCount\":\"nft count to claim\"}},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"MANAGE_ROLE()\":{\"notice\":\"Only MANAGE_ROLE can change mint config\"},\"UPDATE_WL_ROLE()\":{\"notice\":\"Only UPDATE_WL_ROLE can add white listing\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/activity/NFTClaimStage2WL.sol\":\"NFTClaimStage2WL\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/access/AccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAccessControl.sol\\\";\\nimport \\\"../utils/Context.sol\\\";\\nimport \\\"../utils/Strings.sol\\\";\\nimport \\\"../utils/introspection/ERC165.sol\\\";\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```solidity\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```solidity\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\\n * to enforce additional security measures for this role.\\n */\\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\\n struct RoleData {\\n mapping(address => bool) members;\\n bytes32 adminRole;\\n }\\n\\n mapping(bytes32 => RoleData) private _roles;\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with a standardized message including the required role.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n *\\n * _Available since v4.1._\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role);\\n _;\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\\n return _roles[role].members[account];\\n }\\n\\n /**\\n * @dev Revert with a standard message if `_msgSender()` is missing `role`.\\n * Overriding this function changes the behavior of the {onlyRole} modifier.\\n *\\n * Format of the revert message is described in {_checkRole}.\\n *\\n * _Available since v4.6._\\n */\\n function _checkRole(bytes32 role) internal view virtual {\\n _checkRole(role, _msgSender());\\n }\\n\\n /**\\n * @dev Revert with a standard message if `account` is missing `role`.\\n *\\n * The format of the revert reason is given by the following regular expression:\\n *\\n * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n */\\n function _checkRole(bytes32 role, address account) internal view virtual {\\n if (!hasRole(role, account)) {\\n revert(\\n string(\\n abi.encodePacked(\\n \\\"AccessControl: account \\\",\\n Strings.toHexString(account),\\n \\\" is missing role \\\",\\n Strings.toHexString(uint256(role), 32)\\n )\\n )\\n );\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\\n return _roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function renounceRole(bytes32 role, address account) public virtual override {\\n require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event. Note that unlike {grantRole}, this function doesn't perform any\\n * checks on the calling account.\\n *\\n * May emit a {RoleGranted} event.\\n *\\n * [WARNING]\\n * ====\\n * This function should only be called from the constructor when setting\\n * up the initial roles for the system.\\n *\\n * Using this function in any other way is effectively circumventing the admin\\n * system imposed by {AccessControl}.\\n * ====\\n *\\n * NOTE: This function is deprecated in favor of {_grantRole}.\\n */\\n function _setupRole(bytes32 role, address account) internal virtual {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n bytes32 previousAdminRole = getRoleAdmin(role);\\n _roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function _grantRole(bytes32 role, address account) internal virtual {\\n if (!hasRole(role, account)) {\\n _roles[role].members[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n }\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function _revokeRole(bytes32 role, address account) internal virtual {\\n if (hasRole(role, account)) {\\n _roles[role].members[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0dd6e52cb394d7f5abe5dca2d4908a6be40417914720932de757de34a99ab87f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n *\\n * _Available since v3.1._\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `account`.\\n */\\n function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\"},\"@openzeppelin/contracts/security/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Returns true if the reentrancy guard is currently set to \\\"entered\\\", which indicates there is a\\n * `nonReentrant` function in the call stack.\\n */\\n function _reentrancyGuardEntered() internal view returns (bool) {\\n return _status == _ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0xa535a5df777d44e945dd24aa43a11e44b024140fc340ad0dfe42acf4002aade1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `from` to `to` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\n */\\ninterface IERC20Permit {\\n /**\\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n * given ``owner``'s signed approval.\\n *\\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n * ordering also apply here.\\n *\\n * Emits an {Approval} event.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n * - `deadline` must be a timestamp in the future.\\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n * over the EIP712-formatted function arguments.\\n * - the signature must use ``owner``'s current nonce (see {nonces}).\\n *\\n * For more information on the signature format, see the\\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n * section].\\n *\\n * CAUTION: See Security Considerations above.\\n */\\n function permit(\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n /**\\n * @dev Returns the current nonce for `owner`. This value must be\\n * included whenever a signature is generated for {permit}.\\n *\\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n * prevents a signature from being used multiple times.\\n */\\n function nonces(address owner) external view returns (uint256);\\n\\n /**\\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xb264c03a3442eb37a68ad620cefd1182766b58bee6cec40343480392d6b14d69\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/IERC20Permit.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\\n * Revert on invalid signature.\\n */\\n function safePermit(\\n IERC20Permit token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n require(returndata.length == 0 || abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return\\n success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\\n }\\n}\\n\",\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n *\\n * Furthermore, `isContract` will also return true if the target contract within\\n * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n * which only has an effect at the end of a transaction.\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n function _contextSuffixLength() internal view virtual returns (uint256) {\\n return 0;\\n }\\n}\\n\",\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math.sol\\\";\\nimport \\\"./math/SignedMath.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n */\\n function toString(int256 value) internal pure returns (string memory) {\\n return string(abi.encodePacked(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMath.abs(value))));\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n }\\n\\n /**\\n * @dev Returns true if the two strings are equal.\\n */\\n function equal(string memory a, string memory b) internal pure returns (bool) {\\n return keccak256(bytes(a)) == keccak256(bytes(b));\\n }\\n}\\n\",\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165 is IERC165 {\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n // The surrounding unchecked block does not change this fact.\\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1, \\\"Math: mulDiv overflow\\\");\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10 ** 64) {\\n value /= 10 ** 64;\\n result += 64;\\n }\\n if (value >= 10 ** 32) {\\n value /= 10 ** 32;\\n result += 32;\\n }\\n if (value >= 10 ** 16) {\\n value /= 10 ** 16;\\n result += 16;\\n }\\n if (value >= 10 ** 8) {\\n value /= 10 ** 8;\\n result += 8;\\n }\\n if (value >= 10 ** 4) {\\n value /= 10 ** 4;\\n result += 4;\\n }\\n if (value >= 10 ** 2) {\\n value /= 10 ** 2;\\n result += 2;\\n }\\n if (value >= 10 ** 1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMath {\\n /**\\n * @dev Returns the largest of two signed numbers.\\n */\\n function max(int256 a, int256 b) internal pure returns (int256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two signed numbers.\\n */\\n function min(int256 a, int256 b) internal pure returns (int256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two signed numbers without overflow.\\n * The result is rounded towards zero.\\n */\\n function average(int256 a, int256 b) internal pure returns (int256) {\\n // Formula from the book \\\"Hacker's Delight\\\"\\n int256 x = (a & b) + ((a ^ b) >> 1);\\n return x + (int256(uint256(x) >> 255) & (a ^ b));\\n }\\n\\n /**\\n * @dev Returns the absolute unsigned value of a signed value.\\n */\\n function abs(int256 n) internal pure returns (uint256) {\\n unchecked {\\n // must be unchecked in order to support `n = type(int256).min`\\n return uint256(n >= 0 ? n : -n);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)\\n// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for managing\\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\\n * types.\\n *\\n * Sets have the following properties:\\n *\\n * - Elements are added, removed, and checked for existence in constant time\\n * (O(1)).\\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\\n *\\n * ```solidity\\n * contract Example {\\n * // Add the library methods\\n * using EnumerableSet for EnumerableSet.AddressSet;\\n *\\n * // Declare a set state variable\\n * EnumerableSet.AddressSet private mySet;\\n * }\\n * ```\\n *\\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\\n * and `uint256` (`UintSet`) are supported.\\n *\\n * [WARNING]\\n * ====\\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\\n * unusable.\\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\\n *\\n * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an\\n * array of EnumerableSet.\\n * ====\\n */\\nlibrary EnumerableSet {\\n // To implement this library for multiple types with as little code\\n // repetition as possible, we write it in terms of a generic Set type with\\n // bytes32 values.\\n // The Set implementation uses private functions, and user-facing\\n // implementations (such as AddressSet) are just wrappers around the\\n // underlying Set.\\n // This means that we can only create new EnumerableSets for types that fit\\n // in bytes32.\\n\\n struct Set {\\n // Storage of set values\\n bytes32[] _values;\\n // Position of the value in the `values` array, plus 1 because index 0\\n // means a value is not in the set.\\n mapping(bytes32 => uint256) _indexes;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function _add(Set storage set, bytes32 value) private returns (bool) {\\n if (!_contains(set, value)) {\\n set._values.push(value);\\n // The value is stored at length-1, but we add 1 to all indexes\\n // and use 0 as a sentinel value\\n set._indexes[value] = set._values.length;\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function _remove(Set storage set, bytes32 value) private returns (bool) {\\n // We read and store the value's index to prevent multiple reads from the same storage slot\\n uint256 valueIndex = set._indexes[value];\\n\\n if (valueIndex != 0) {\\n // Equivalent to contains(set, value)\\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\\n // the array, and then remove the last element (sometimes called as 'swap and pop').\\n // This modifies the order of the array, as noted in {at}.\\n\\n uint256 toDeleteIndex = valueIndex - 1;\\n uint256 lastIndex = set._values.length - 1;\\n\\n if (lastIndex != toDeleteIndex) {\\n bytes32 lastValue = set._values[lastIndex];\\n\\n // Move the last value to the index where the value to delete is\\n set._values[toDeleteIndex] = lastValue;\\n // Update the index for the moved value\\n set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex\\n }\\n\\n // Delete the slot where the moved value was stored\\n set._values.pop();\\n\\n // Delete the index for the deleted slot\\n delete set._indexes[value];\\n\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\\n return set._indexes[value] != 0;\\n }\\n\\n /**\\n * @dev Returns the number of values on the set. O(1).\\n */\\n function _length(Set storage set) private view returns (uint256) {\\n return set._values.length;\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\\n return set._values[index];\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function _values(Set storage set) private view returns (bytes32[] memory) {\\n return set._values;\\n }\\n\\n // Bytes32Set\\n\\n struct Bytes32Set {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _add(set._inner, value);\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\\n return _remove(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\\n return _contains(set._inner, value);\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(Bytes32Set storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\\n return _at(set._inner, index);\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n bytes32[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n\\n // AddressSet\\n\\n struct AddressSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(AddressSet storage set, address value) internal returns (bool) {\\n return _add(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(AddressSet storage set, address value) internal returns (bool) {\\n return _remove(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(AddressSet storage set, address value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(uint256(uint160(value))));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(AddressSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\\n return address(uint160(uint256(_at(set._inner, index))));\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(AddressSet storage set) internal view returns (address[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n address[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n\\n // UintSet\\n\\n struct UintSet {\\n Set _inner;\\n }\\n\\n /**\\n * @dev Add a value to a set. O(1).\\n *\\n * Returns true if the value was added to the set, that is if it was not\\n * already present.\\n */\\n function add(UintSet storage set, uint256 value) internal returns (bool) {\\n return _add(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Removes a value from a set. O(1).\\n *\\n * Returns true if the value was removed from the set, that is if it was\\n * present.\\n */\\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\\n return _remove(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns true if the value is in the set. O(1).\\n */\\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\\n return _contains(set._inner, bytes32(value));\\n }\\n\\n /**\\n * @dev Returns the number of values in the set. O(1).\\n */\\n function length(UintSet storage set) internal view returns (uint256) {\\n return _length(set._inner);\\n }\\n\\n /**\\n * @dev Returns the value stored at position `index` in the set. O(1).\\n *\\n * Note that there are no guarantees on the ordering of values inside the\\n * array, and it may change when more values are added or removed.\\n *\\n * Requirements:\\n *\\n * - `index` must be strictly less than {length}.\\n */\\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\\n return uint256(_at(set._inner, index));\\n }\\n\\n /**\\n * @dev Return the entire set in an array\\n *\\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n */\\n function values(UintSet storage set) internal view returns (uint256[] memory) {\\n bytes32[] memory store = _values(set._inner);\\n uint256[] memory result;\\n\\n /// @solidity memory-safe-assembly\\n assembly {\\n result := store\\n }\\n\\n return result;\\n }\\n}\\n\",\"keccak256\":\"0x9f4357008a8f7d8c8bf5d48902e789637538d8c016be5766610901b4bba81514\",\"license\":\"MIT\"},\"contracts/activity/NFTClaimStage2WL.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.19;\\n\\nimport {ReentrancyGuard} from \\\"@openzeppelin/contracts/security/ReentrancyGuard.sol\\\";\\nimport {IERC20} from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport {AccessControl} from \\\"@openzeppelin/contracts/access/AccessControl.sol\\\";\\nimport {EnumerableSet} from \\\"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\\\";\\nimport {SafeERC20} from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n/**\\n * Contract for the activity of NFT claim stage 2.\\n */\\ninterface IClaimAbleNFT {\\n function safeMint(address to, uint256 tokenID) external;\\n}\\n\\ncontract NFTClaimStage2WL is ReentrancyGuard, AccessControl {\\n using EnumerableSet for EnumerableSet.UintSet;\\n using SafeERC20 for IERC20;\\n /// @notice Only UPDATE_WL_ROLE can add white listing\\n bytes32 public constant UPDATE_WL_ROLE = bytes32(\\\"UPDATE_WL_ROLE\\\");\\n /// @notice Only MANAGE_ROLE can change mint config\\n bytes32 public constant MANAGE_ROLE = keccak256(\\\"MANAGE_ROLE\\\");\\n\\n struct MintConfig {\\n uint256 maxSupply; // max supply for phase2\\n address currency; // token address which user must pay to mint\\n uint256 mintPrice; // in wei\\n address feeToAddress; // wallet address to receive mint fee\\n uint256 airdropCount; // airdrop count\\n }\\n // parse: 0: not open or end, 1: phase1, 2: phase2\\n uint256 public mintParse = 0;\\n address public nftAddress;\\n uint256 public nftIdStart;\\n\\n MintConfig public mintConfig;\\n uint256 public totalCount;\\n mapping(address user => uint256 num) private _whitelist1;\\n mapping(address user => uint256 num) private _whitelist2;\\n mapping(address user => EnumerableSet.UintSet tokenIdSet) private _mintedRecords;\\n \\n\\n event NFTClaimed(address indexed nftAddress, address indexed to, uint256[] ids);\\n\\n event ParseUpdated(uint256 _parse);\\n event MintConfigUpdated(MintConfig config);\\n event NFTAddressUpdated(address _nft);\\n event NFTIdStartUpdated(uint256 _nftIdStart);\\n\\n constructor(address _nftAddress, uint256 _nftIdStart, MintConfig memory _mintConfig) {\\n _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());\\n _grantRole(UPDATE_WL_ROLE, _msgSender());\\n _grantRole(MANAGE_ROLE, _msgSender());\\n nftAddress = _nftAddress;\\n mintConfig = _mintConfig;\\n nftIdStart = _nftIdStart;\\n }\\n\\n modifier whenNotPaused() {\\n require(mintParse > 0, \\\"NFTClaimer: not begin or ended\\\");\\n _;\\n }\\n\\n function updateMintParse(uint256 _mintParse) external onlyRole(MANAGE_ROLE) {\\n require(_mintParse == 0 || _mintParse == 1 || _mintParse == 2, \\\"NFTClaimer: invalid mintParse\\\");\\n mintParse = _mintParse;\\n emit ParseUpdated(_mintParse);\\n }\\n\\n function updateMintConfig(MintConfig calldata config) external onlyRole(MANAGE_ROLE) {\\n mintConfig = config;\\n emit MintConfigUpdated(config);\\n }\\n\\n function addParse1WL(address[] calldata _addressList, uint256[] calldata _nums) external onlyRole(UPDATE_WL_ROLE) {\\n require(_addressList.length == _nums.length, \\\"NFTClaimer: invalid whitelist\\\");\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n _whitelist1[_addressList[i]] = _nums[i];\\n }\\n }\\n\\n function revokeParse1WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n delete _whitelist1[_addressList[i]];\\n }\\n }\\n\\n function addParse2WL(address[] calldata _addressList) external onlyRole(UPDATE_WL_ROLE){\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n _whitelist2[_addressList[i]] = 1;\\n }\\n }\\n\\n function revokeParse2WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\\n for (uint256 i = 0; i < _addressList.length; i++) {\\n delete _whitelist2[_addressList[i]];\\n }\\n }\\n\\n function updateNftAddress(address _nft) external onlyRole(MANAGE_ROLE) {\\n require(_nft != address(0), \\\"NFTClaimer: invalid nft address\\\");\\n nftAddress = _nft;\\n emit NFTAddressUpdated(_nft);\\n }\\n\\n function updateNftIdStart(uint256 _nftIdStart) external onlyRole(MANAGE_ROLE) {\\n nftIdStart = _nftIdStart;\\n emit NFTIdStartUpdated(_nftIdStart);\\n }\\n\\n\\n /**\\n * @dev claim NFT\\n * @param nftCount nft count to claim\\n */\\n function claim(\\n uint256 nftCount\\n ) external nonReentrant whenNotPaused {\\n require(nftCount > 0, \\\"NFTClaimer: nft count must be greater than 0\\\");\\n require(nftCount <= mintConfig.maxSupply - mintConfig.airdropCount - totalCount, \\\"NFTClaimer: exceed max supply\\\");\\n address to = _msgSender();\\n uint256 _mintedCount = _mintedRecords[to].length();\\n if (mintParse == 1) {\\n require(_whitelist1[to] >= _mintedCount + nftCount, \\\"NFTClaimer: not in whitelist or exceed limit\\\");\\n } else if (mintParse == 2) {\\n require(_whitelist1[to] + _whitelist2[to] >= _mintedCount + nftCount, \\\"NFTClaimer: not in whitelist or exceed limit\\\");\\n }\\n uint256 _tokenAmount = mintConfig.mintPrice * nftCount;\\n IERC20(mintConfig.currency).safeTransferFrom(to, mintConfig.feeToAddress, _tokenAmount);\\n uint256[] memory ids = new uint256[](nftCount);\\n for (uint256 i = 0; i < nftCount; ++i) {\\n uint256 _nftId = nftIdStart + totalCount + i;\\n ids[i] = _nftId;\\n _mintedRecords[to].add(_nftId);\\n IClaimAbleNFT(nftAddress).safeMint(to, _nftId);\\n }\\n totalCount += nftCount;\\n emit NFTClaimed(nftAddress, to, ids);\\n }\\n\\n function queryInfo() external view returns (uint256 num1, uint256 num2, uint256 minted) {\\n num1 = _whitelist1[_msgSender()];\\n num2 = _whitelist2[_msgSender()];\\n minted = _mintedRecords[_msgSender()].length();\\n return (num1, num2, minted);\\n }\\n\\n\\n function mintedNum() external view returns (uint256){\\n return _mintedRecords[_msgSender()].length();\\n }\\n\\n function mintedNft() external view returns (uint256[] memory){\\n return _mintedRecords[_msgSender()].values();\\n }\\n\\n}\\n\",\"keccak256\":\"0xf7778e4b86ed61af59d75bec5393c880fff0e620ad353586b0914ef5160b7e71\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", "devdoc": { "events": { "RoleAdminChanged(bytes32,bytes32,bytes32)": { @@ -772,12 +824,28 @@ "slot": "2", "type": "t_uint256" }, + { + "astId": 3214, + "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", + "label": "nftAddress", + "offset": 0, + "slot": "3", + "type": "t_address" + }, + { + "astId": 3216, + "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", + "label": "nftIdStart", + "offset": 0, + "slot": "4", + "type": "t_uint256" + }, { "astId": 3219, "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", "label": "mintConfig", "offset": 0, - "slot": "3", + "slot": "5", "type": "t_struct(MintConfig)3209_storage" }, { @@ -785,7 +853,7 @@ "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", "label": "totalCount", "offset": 0, - "slot": "8", + "slot": "10", "type": "t_uint256" }, { @@ -793,7 +861,7 @@ "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", "label": "_whitelist1", "offset": 0, - "slot": "9", + "slot": "11", "type": "t_mapping(t_address,t_uint256)" }, { @@ -801,7 +869,7 @@ "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", "label": "_whitelist2", "offset": 0, - "slot": "10", + "slot": "12", "type": "t_mapping(t_address,t_uint256)" }, { @@ -809,7 +877,7 @@ "contract": "contracts/activity/NFTClaimStage2WL.sol:NFTClaimStage2WL", "label": "_mintedRecords", "offset": 0, - "slot": "11", + "slot": "13", "type": "t_mapping(t_address,t_struct(UintSet)3022_storage)" } ], diff --git a/deployments/imtbl_test/solcInputs/51bc58a876e88f27d12eca799d1f4f63.json b/deployments/imtbl_test/solcInputs/7a21470cd04b53fd0b413c61220c019c.json similarity index 94% rename from deployments/imtbl_test/solcInputs/51bc58a876e88f27d12eca799d1f4f63.json rename to deployments/imtbl_test/solcInputs/7a21470cd04b53fd0b413c61220c019c.json index 0df9bf4..2a8d557 100644 --- a/deployments/imtbl_test/solcInputs/51bc58a876e88f27d12eca799d1f4f63.json +++ b/deployments/imtbl_test/solcInputs/7a21470cd04b53fd0b413c61220c019c.json @@ -44,7 +44,7 @@ "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)\n// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```solidity\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n *\n * [WARNING]\n * ====\n * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure\n * unusable.\n * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.\n *\n * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an\n * array of EnumerableSet.\n * ====\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping(bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) {\n // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n if (lastIndex != toDeleteIndex) {\n bytes32 lastValue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastValue;\n // Update the index for the moved value\n set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex\n }\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n return set._values[index];\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function _values(Set storage set) private view returns (bytes32[] memory) {\n return set._values;\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\n bytes32[] memory store = _values(set._inner);\n bytes32[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(AddressSet storage set) internal view returns (address[] memory) {\n bytes32[] memory store = _values(set._inner);\n address[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(UintSet storage set) internal view returns (uint256[] memory) {\n bytes32[] memory store = _values(set._inner);\n uint256[] memory result;\n\n /// @solidity memory-safe-assembly\n assembly {\n result := store\n }\n\n return result;\n }\n}\n" }, "contracts/activity/NFTClaimStage2WL.sol": { - "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.19;\n\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/security/ReentrancyGuard.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {AccessControl} from \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport {EnumerableSet} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n/**\n * Contract for the activity of NFT claim stage 2.\n */\ninterface IClaimAbleNFT {\n function safeMint(address to, uint256 tokenID) external;\n}\n\ncontract NFTClaimStage2WL is ReentrancyGuard, AccessControl {\n using EnumerableSet for EnumerableSet.UintSet;\n using SafeERC20 for IERC20;\n /// @notice Only UPDATE_WL_ROLE can add white listing\n bytes32 public constant UPDATE_WL_ROLE = bytes32(\"UPDATE_WL_ROLE\");\n /// @notice Only MANAGE_ROLE can change mint config\n bytes32 public constant MANAGE_ROLE = keccak256(\"MANAGE_ROLE\");\n\n struct MintConfig {\n uint256 maxSupply; // max supply for phase2\n address currency; // token address which user must pay to mint\n uint256 mintPrice; // in wei\n address feeToAddress; // wallet address to receive mint fee\n uint256 airdropCount; // airdrop count\n }\n // parse: 0: not open or end, 1: phase1, 2: phase2\n uint256 public mintParse = 0;\n address public immutable nftAddress;\n uint256 public immutable nftIdStart;\n\n MintConfig public mintConfig;\n uint256 public totalCount;\n mapping(address user => uint256 num) private _whitelist1;\n mapping(address user => uint256 num) private _whitelist2;\n mapping(address user => EnumerableSet.UintSet tokenIdSet) private _mintedRecords;\n \n\n event NFTClaimed(address indexed nftAddress, address indexed to, uint256[] ids);\n\n event ParseUpdated(uint256 _parse);\n event MintConfigUpdated(MintConfig config);\n\n constructor(address _nftAddress, uint256 _nftIdStart, MintConfig memory _mintConfig) {\n _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());\n _grantRole(UPDATE_WL_ROLE, _msgSender());\n _grantRole(MANAGE_ROLE, _msgSender());\n nftAddress = _nftAddress;\n mintConfig = _mintConfig;\n nftIdStart = _nftIdStart;\n }\n\n modifier whenNotPaused() {\n require(mintParse > 0, \"NFTClaimer: not begin or ended\");\n _;\n }\n\n function updateMintParse(uint256 _mintParse) external onlyRole(MANAGE_ROLE) {\n require(_mintParse == 0 || _mintParse == 1 || _mintParse == 2, \"NFTClaimer: invalid mintParse\");\n mintParse = _mintParse;\n emit ParseUpdated(_mintParse);\n }\n\n function updateMintConfig(MintConfig calldata config) external onlyRole(MANAGE_ROLE) {\n mintConfig = config;\n emit MintConfigUpdated(config);\n }\n\n function addParse1WL(address[] calldata _addressList, uint256[] calldata _nums) external onlyRole(UPDATE_WL_ROLE) {\n require(_addressList.length == _nums.length, \"NFTClaimer: invalid whitelist\");\n for (uint256 i = 0; i < _addressList.length; i++) {\n _whitelist1[_addressList[i]] = _nums[i];\n }\n }\n\n function revokeParse1WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\n for (uint256 i = 0; i < _addressList.length; i++) {\n delete _whitelist1[_addressList[i]];\n }\n }\n\n function addParse2WL(address[] calldata _addressList) external onlyRole(UPDATE_WL_ROLE){\n for (uint256 i = 0; i < _addressList.length; i++) {\n _whitelist2[_addressList[i]] = 1;\n }\n }\n\n function revokeParse2WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\n for (uint256 i = 0; i < _addressList.length; i++) {\n delete _whitelist2[_addressList[i]];\n }\n }\n\n\n /**\n * @dev claim NFT\n * @param nftCount nft count to claim\n */\n function claim(\n uint256 nftCount\n ) external nonReentrant whenNotPaused {\n require(nftCount > 0, \"NFTClaimer: nft count must be greater than 0\");\n require(nftCount <= mintConfig.maxSupply - mintConfig.airdropCount - totalCount, \"NFTClaimer: exceed max supply\");\n address to = _msgSender();\n uint256 _mintedCount = _mintedRecords[to].length();\n if (mintParse == 1) {\n require(_whitelist1[to] >= _mintedCount + nftCount, \"NFTClaimer: not in whitelist or exceed limit\");\n } else if (mintParse == 2) {\n require(_whitelist1[to] + _whitelist2[to] >= _mintedCount + nftCount, \"NFTClaimer: not in whitelist or exceed limit\");\n }\n uint256 _tokenAmount = mintConfig.mintPrice * nftCount;\n totalCount += nftCount;\n IERC20(mintConfig.currency).safeTransferFrom(to, mintConfig.feeToAddress, _tokenAmount);\n uint256[] memory ids = new uint256[](nftCount);\n for (uint256 i = 0; i < nftCount; ++i) {\n uint256 _nftId = nftIdStart + totalCount + i;\n ids[i] = _nftId;\n _mintedRecords[to].add(_nftId);\n IClaimAbleNFT(nftAddress).safeMint(to, _nftId);\n }\n emit NFTClaimed(nftAddress, to, ids);\n }\n\n function queryInfo() external view returns (uint256 num1, uint256 num2, uint256 minted) {\n num1 = _whitelist1[_msgSender()];\n num2 = _whitelist2[_msgSender()];\n minted = _mintedRecords[_msgSender()].length();\n return (num1, num2, minted);\n }\n\n\n function mintedNum() external view returns (uint256){\n return _mintedRecords[_msgSender()].length();\n }\n\n function mintedNft() external view returns (uint256[] memory){\n return _mintedRecords[_msgSender()].values();\n }\n\n}\n" + "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.19;\n\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/security/ReentrancyGuard.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {AccessControl} from \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport {EnumerableSet} from \"@openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\n/**\n * Contract for the activity of NFT claim stage 2.\n */\ninterface IClaimAbleNFT {\n function safeMint(address to, uint256 tokenID) external;\n}\n\ncontract NFTClaimStage2WL is ReentrancyGuard, AccessControl {\n using EnumerableSet for EnumerableSet.UintSet;\n using SafeERC20 for IERC20;\n /// @notice Only UPDATE_WL_ROLE can add white listing\n bytes32 public constant UPDATE_WL_ROLE = bytes32(\"UPDATE_WL_ROLE\");\n /// @notice Only MANAGE_ROLE can change mint config\n bytes32 public constant MANAGE_ROLE = keccak256(\"MANAGE_ROLE\");\n\n struct MintConfig {\n uint256 maxSupply; // max supply for phase2\n address currency; // token address which user must pay to mint\n uint256 mintPrice; // in wei\n address feeToAddress; // wallet address to receive mint fee\n uint256 airdropCount; // airdrop count\n }\n // parse: 0: not open or end, 1: phase1, 2: phase2\n uint256 public mintParse = 0;\n address public nftAddress;\n uint256 public nftIdStart;\n\n MintConfig public mintConfig;\n uint256 public totalCount;\n mapping(address user => uint256 num) private _whitelist1;\n mapping(address user => uint256 num) private _whitelist2;\n mapping(address user => EnumerableSet.UintSet tokenIdSet) private _mintedRecords;\n \n\n event NFTClaimed(address indexed nftAddress, address indexed to, uint256[] ids);\n\n event ParseUpdated(uint256 _parse);\n event MintConfigUpdated(MintConfig config);\n event NFTAddressUpdated(address _nft);\n event NFTIdStartUpdated(uint256 _nftIdStart);\n\n constructor(address _nftAddress, uint256 _nftIdStart, MintConfig memory _mintConfig) {\n _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());\n _grantRole(UPDATE_WL_ROLE, _msgSender());\n _grantRole(MANAGE_ROLE, _msgSender());\n nftAddress = _nftAddress;\n mintConfig = _mintConfig;\n nftIdStart = _nftIdStart;\n }\n\n modifier whenNotPaused() {\n require(mintParse > 0, \"NFTClaimer: not begin or ended\");\n _;\n }\n\n function updateMintParse(uint256 _mintParse) external onlyRole(MANAGE_ROLE) {\n require(_mintParse == 0 || _mintParse == 1 || _mintParse == 2, \"NFTClaimer: invalid mintParse\");\n mintParse = _mintParse;\n emit ParseUpdated(_mintParse);\n }\n\n function updateMintConfig(MintConfig calldata config) external onlyRole(MANAGE_ROLE) {\n mintConfig = config;\n emit MintConfigUpdated(config);\n }\n\n function addParse1WL(address[] calldata _addressList, uint256[] calldata _nums) external onlyRole(UPDATE_WL_ROLE) {\n require(_addressList.length == _nums.length, \"NFTClaimer: invalid whitelist\");\n for (uint256 i = 0; i < _addressList.length; i++) {\n _whitelist1[_addressList[i]] = _nums[i];\n }\n }\n\n function revokeParse1WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\n for (uint256 i = 0; i < _addressList.length; i++) {\n delete _whitelist1[_addressList[i]];\n }\n }\n\n function addParse2WL(address[] calldata _addressList) external onlyRole(UPDATE_WL_ROLE){\n for (uint256 i = 0; i < _addressList.length; i++) {\n _whitelist2[_addressList[i]] = 1;\n }\n }\n\n function revokeParse2WL(address[] calldata _addressList) external onlyRole(MANAGE_ROLE) {\n for (uint256 i = 0; i < _addressList.length; i++) {\n delete _whitelist2[_addressList[i]];\n }\n }\n\n function updateNftAddress(address _nft) external onlyRole(MANAGE_ROLE) {\n require(_nft != address(0), \"NFTClaimer: invalid nft address\");\n nftAddress = _nft;\n emit NFTAddressUpdated(_nft);\n }\n\n function updateNftIdStart(uint256 _nftIdStart) external onlyRole(MANAGE_ROLE) {\n nftIdStart = _nftIdStart;\n emit NFTIdStartUpdated(_nftIdStart);\n }\n\n\n /**\n * @dev claim NFT\n * @param nftCount nft count to claim\n */\n function claim(\n uint256 nftCount\n ) external nonReentrant whenNotPaused {\n require(nftCount > 0, \"NFTClaimer: nft count must be greater than 0\");\n require(nftCount <= mintConfig.maxSupply - mintConfig.airdropCount - totalCount, \"NFTClaimer: exceed max supply\");\n address to = _msgSender();\n uint256 _mintedCount = _mintedRecords[to].length();\n if (mintParse == 1) {\n require(_whitelist1[to] >= _mintedCount + nftCount, \"NFTClaimer: not in whitelist or exceed limit\");\n } else if (mintParse == 2) {\n require(_whitelist1[to] + _whitelist2[to] >= _mintedCount + nftCount, \"NFTClaimer: not in whitelist or exceed limit\");\n }\n uint256 _tokenAmount = mintConfig.mintPrice * nftCount;\n IERC20(mintConfig.currency).safeTransferFrom(to, mintConfig.feeToAddress, _tokenAmount);\n uint256[] memory ids = new uint256[](nftCount);\n for (uint256 i = 0; i < nftCount; ++i) {\n uint256 _nftId = nftIdStart + totalCount + i;\n ids[i] = _nftId;\n _mintedRecords[to].add(_nftId);\n IClaimAbleNFT(nftAddress).safeMint(to, _nftId);\n }\n totalCount += nftCount;\n emit NFTClaimed(nftAddress, to, ids);\n }\n\n function queryInfo() external view returns (uint256 num1, uint256 num2, uint256 minted) {\n num1 = _whitelist1[_msgSender()];\n num2 = _whitelist2[_msgSender()];\n minted = _mintedRecords[_msgSender()].length();\n return (num1, num2, minted);\n }\n\n\n function mintedNum() external view returns (uint256){\n return _mintedRecords[_msgSender()].length();\n }\n\n function mintedNft() external view returns (uint256[] memory){\n return _mintedRecords[_msgSender()].values();\n }\n\n}\n" } }, "settings": { diff --git a/out/imtbl_test_dev.json b/out/imtbl_test_dev.json index 48db191..1a0a8ed 100644 --- a/out/imtbl_test_dev.json +++ b/out/imtbl_test_dev.json @@ -29,10 +29,16 @@ "json": "assets/contracts/CFNFTGame.json", "address": "0x75C0c6eD851036DB28c750Bd9bfa3A72B5107801" }, + { + "name": "AirdropToken", + "type": "logic", + "json": "assets/contracts/AirdropToken.json", + "address": "0x4Ef766854EE104053cF2D243620b7A643fCC2B54" + }, { "name": "NFTClaimStage2WL", "type": "logic", "json": "assets/contracts/NFTClaimStage2WL.json", - "address": "0xc43Efb17C24e4e027d3F2613DB858181abE2994e" + "address": "0xc11A64Cc2Ec7aEFbd5E25a37f1d9216f3f8CF11a" } ] \ No newline at end of file diff --git a/package.json b/package.json index 7de3450..6ff7c96 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,7 @@ "deploy:nft": "hardhat deploy --tags CFNFTGame --network imtbl_test --reset", "deploy:nftlock": "hardhat deploy --tags NFTLock --network imtbl_test --reset", "deploy:testtoken": "hardhat deploy --tags TestToken --network imtbl_test --reset", + "deploy:airdrop": "hardhat deploy --tags AirdropToken --network imtbl_test --reset", "solhint": "solhint --config ./.solhint.json" }, "author": "",