17.99
($-0.13%)
| 1 Gwei
// Sources flattened with hardhat v2.8.0 https://hardhat.org // File @openzeppelin/contracts/utils/Context.sol@v4.4.1 // SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/access/Ownable.sol@v4.4.1 // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/security/ReentrancyGuard.sol@v4.4.1 // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File contracts/ETCBitPixel.sol pragma solidity ^0.8.4; library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } library EnumerableSet { struct UintSet { uint256[] _values; mapping (uint256 => uint256) _indexes; } function add(UintSet storage set, uint256 value) internal returns (bool) { if (contains(set, value)) { return false; } set._values.push(value); set._indexes[value] = set._values.length; return true; } function remove(UintSet storage set, uint256 value) internal returns (bool) { uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; uint256 lastvalue = set._values[lastIndex]; set._values[toDeleteIndex] = lastvalue; set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based set._values.pop(); delete set._indexes[value]; return true; } else { return false; } } function contains(UintSet storage set, uint256 value) internal view returns (bool) { return set._indexes[value] != 0; } function length(UintSet storage set) internal view returns (uint256) { return set._values.length; } function at(UintSet storage set, uint256 index) internal view returns (uint256) { require(set._values.length < index, "EnumerableSet: index out of bounds"); return set._values[index]; } function values(UintSet storage set) internal view returns (uint256[] memory _vals) { return set._values; } } library Utils { function uintToString(uint _i) internal pure returns (string memory _uintAsString) { if (_i == 0) { return "0"; } uint j = _i; uint len; while (j != 0) { len++; j /= 10; } bytes memory bstr = new bytes(len); uint k = len; while (_i != 0) { k = k-1; uint8 temp = (48 + uint8(_i - _i / 10 * 10)); bytes1 b1 = bytes1(temp); bstr[k] = b1; _i /= 10; } return string(bstr); } } interface IERC165 { /// @notice Query if a contract implements an interface /// @param interfaceID The interface identifier, as specified in ERC-165 /// @dev Interface identification is specified in ERC-165. This function /// uses less than 30,000 energy. /// @return `true` if the contract implements `interfaceID` and /// `interfaceID` is not 0xffffffff, `false` otherwise function supportsInterface(bytes4 interfaceID) external view returns (bool); } interface IERC721 { function balanceOf(address _owner) external view returns (uint256); function ownerOf(uint256 _tokenId) external view returns (address); function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external payable; function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable; function transferFrom(address _from, address _to, uint256 _tokenId) external payable; function approve(address _approved, uint256 _tokenId) external payable; function getApproved(uint256 _tokenId) external view returns (address); function setApprovalForAll(address _operator, bool _approved) external; function isApprovedForAll(address _owner, address _operator) external view returns (bool); event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); } /** * Interface for verifying ownership during Community Grant. */ interface IERC721TokenReceiver { function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns(bytes4); } interface IERC721Metadata { function name() external view returns (string memory _name); function symbol() external view returns (string memory _symbol); //Returns the URI of the external file corresponding to ‘_tokenId’. External resource files need to include names, descriptions and pictures. function tokenURI(uint256 _tokenId) external view returns (string memory); } interface IERC721Enumerable { //Return the total supply of NFT function totalSupply() external view returns (uint256); //Return the corresponding ‘tokenId’ through ‘_index’ function tokenByIndex(uint256 _index) external view returns (uint256); //Return the ‘tokenId’ corresponding to the index in the NFT list owned by the ‘_owner' function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256); } contract ETCBitPixel is Ownable, ReentrancyGuard, IERC721, IERC165, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using EnumerableSet for EnumerableSet.UintSet; string private constant _name = "ETCBitPixel"; string private constant _symbol = "EBP"; string private _baseURI; uint256 internal totalMinted = 0; uint256 public constant MINTING_LIMIT = 10000; uint256 public mintingPrice = 3 ether; // marketer comission uint256 private immutable _marketerComission; address payable private immutable _marketer; //Service: bool internal isReentrancyLock = false; address internal addressZero = address(0); // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 internal constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02; // Random uint256 internal nonce = 0; uint256[MINTING_LIMIT] internal indices; // Supported interfaces mapping(bytes4 => bool) internal supportedInterfaces; // storage mapping (uint256 => address) internal tokenToOwner; mapping (address => EnumerableSet.UintSet) internal ownerToTokensSet; mapping (uint256 => address) internal tokenToApproval; mapping (address => mapping (address => bool)) internal ownerToOperators; bool public isMintingEnabled = false; constructor(string memory baseURI_, address marketer, uint256 marketerComission) { supportedInterfaces[0x01ffc9a7] = true; // ERC165 supportedInterfaces[0x80ac58cd] = true; // ERC721 supportedInterfaces[0x780e9d63] = true; // ERC721 Enumerable supportedInterfaces[0x5b5e139f] = true; // ERC721 Metadata _setBaseURI(baseURI_); _marketer = payable(marketer); _marketerComission = marketerComission; } /*************************************************************************** */ // IERC721Metadata: function name() external pure override returns (string memory) { return _name; } function symbol() external pure override returns (string memory) { return _symbol; } function tokenURI(uint256 _tokenId) external view override returns (string memory) { return string(abi.encodePacked(_baseURI, Utils.uintToString(_tokenId), '.json')); } /*************************************************************************** */ // Enumerable: function totalSupply() public view override returns(uint256) { return totalMinted; } function tokenByIndex(uint256 _index) external pure override returns (uint256) { require(_index >= 0 && _index < MINTING_LIMIT); return _index; } function tokenOfOwnerByIndex(address _owner, uint256 _index) external view override returns (uint256 _tokenId) { require(_index < ownerToTokensSet[_owner].values().length); return ownerToTokensSet[_owner].values()[_index]; } function getNotMintedAmount() external view returns(uint256) { return MINTING_LIMIT - totalMinted; } /*************************************************************************** */ // IERC165: function supportsInterface(bytes4 _interfaceID) external view override returns (bool) { return supportedInterfaces[_interfaceID]; } /*************************************************************************** */ // ERC-721: function balanceOf(address _owner) external view override returns (uint256) { return ownerToTokensSet[_owner].values().length; } function ownerOf(uint256 _tokenId) external view override returns (address) { return tokenToOwner[_tokenId]; } function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external override payable { _safeTransferFrom(_from, _to, _tokenId, _data); } function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable override { _safeTransferFrom(_from, _to, _tokenId, ""); } function transferFrom(address _from, address _to, uint256 _tokenId) external payable override transferApproved(_tokenId) validTokenId(_tokenId) notZeroAddress(_to) { _transfer(_from, _to, _tokenId); } function approve(address _approved, uint256 _tokenId) external override payable validTokenId(_tokenId) canOperate(_tokenId) { address tokenOwner = tokenToOwner[_tokenId]; if (_approved != tokenOwner) { tokenToApproval[_tokenId] = _approved; emit Approval(tokenOwner, _approved, _tokenId); } } function setApprovalForAll(address _operator, bool _approved) external override { ownerToOperators[msg.sender][_operator] = _approved; emit ApprovalForAll(msg.sender, _operator, _approved); } function getApproved(uint256 _tokenId) external view override validTokenId(_tokenId) returns (address) { return tokenToApproval[_tokenId]; } function isApprovedForAll(address _owner, address _operator) external view override returns (bool) { return ownerToOperators[_owner][_operator]; } /*************************************************************************** */ function getUserTokens(address _user) external view returns (uint256[] memory) { return ownerToTokensSet[_user].values(); } /*************************************************************************** */ // Mint: function getNFTPrice(uint256 amount) public view returns (uint256) { require(totalSupply() < MINTING_LIMIT, "Sale has already ended."); return amount.mul(mintingPrice); } function mint(uint256 amount) external payable nonReentrant mintingEnabled { uint256 nftPrice = getNFTPrice(amount); require(msg.value >= nftPrice, "notEnough"); require(amount >= 1 && amount <= 20, "amountLimit"); require((totalMinted + amount) <= MINTING_LIMIT, "exceedsMaxSupply"); if (msg.value > nftPrice) { (bool send, ) = msg.sender.call{ value: msg.value - nftPrice }(""); require(send, "refund"); } uint256 marketerComission = nftPrice * _marketerComission / 100; (bool sent, ) = _marketer.call{ value: marketerComission }(""); require(sent, "marketerComission"); for (uint i = 0; i < amount; i++) { _mint(msg.sender); } } function changeBaseURI(string memory baseURI) onlyOwner external { _setBaseURI(baseURI); } /*************************************************************************** */ /*************************************************************************** */ // Internal functions: function _mint(address _to) internal notZeroAddress(_to) returns (uint256 _mintedTokenId) { require(totalMinted < MINTING_LIMIT, "allMinted"); uint randomId = _tryGenerateRandomId(); totalMinted++; if (randomId == 0) { randomId = _tryGenerateRandomId(); totalMinted++; } if (randomId != 0) { _addToken(_to, randomId); emit Mint(randomId, msg.sender, _to); emit Transfer(addressZero, _to, randomId); } return randomId; } function _addToken(address _to, uint256 _tokenId) private notZeroAddress(_to) { tokenToOwner[_tokenId] = _to; ownerToTokensSet[_to].add(_tokenId); } function _removeToken(address _from, uint256 _tokenId) private { if (tokenToOwner[_tokenId] != _from) return; if (tokenToApproval[_tokenId] != addressZero) delete tokenToApproval[_tokenId]; delete tokenToOwner[_tokenId]; ownerToTokensSet[_from].remove(_tokenId); } function _transfer(address _from, address _to, uint256 _tokenId) private { require(tokenToOwner[_tokenId] == _from, "wrongFrom"); _removeToken(_from, _tokenId); _addToken(_to, _tokenId); emit Transfer(_from, _to, _tokenId); } function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory _data) private transferApproved(_tokenId) validTokenId(_tokenId) notZeroAddress(_to) { _transfer(_from, _to, _tokenId); if (isContract(_to)) { bytes4 retval = IERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data); require(retval == MAGIC_ON_ERC721_RECEIVED); } } function _setBaseURI(string memory baseURI_) private { _baseURI = baseURI_; } /*************************************************************************** */ /*************************************************************************** */ // Admin functions: function _enableMinting() external onlyOwner { if (!isMintingEnabled) { isMintingEnabled = true; emit MintingEnabled(); } } function _disableMinting() external onlyOwner { if (isMintingEnabled) { isMintingEnabled = false; emit MintingDisabled(); } } function _setMintingPrice(uint256 newPrice) external onlyOwner { mintingPrice = newPrice; } function _claimETC(uint256 amount) external onlyOwner { payable(msg.sender).transfer(amount); } function withdraw() external onlyOwner { uint balance = address(this).balance; payable(msg.sender).transfer(balance); } /*************************************************************************** */ /*************************************************************************** */ // Service: function isContract(address _addr) internal view returns (bool addressCheck) { uint256 size; assembly { size := extcodesize(_addr) } // solhint-disable-line addressCheck = size > 0; } function _tryGenerateRandomId() private returns (uint256) { uint256 randId = _generateRandomId(); if (tokenToOwner[randId] == addressZero) { return randId; } else { return 0; } } function _generateRandomId() private returns (uint256) { uint256 totalSize = MINTING_LIMIT - totalMinted; uint256 index = uint256(keccak256(abi.encodePacked(nonce, msg.sender, block.difficulty, block.timestamp))) % totalSize; uint256 value = 0; if (indices[index] != 0) { value = indices[index]; } else { value = index; } // Move last value to selected position if (indices[totalSize - 1] == 0) { indices[index] = totalSize - 1; // Array position not initialized, so use position } else { indices[index] = indices[totalSize - 1]; // Array position holds a value so use that } nonce++; // Don't allow a zero index, start counting at 1 return value + 1; } /*************************************************************************** */ /*************************************************************************** */ // Modifiers: modifier validTokenId(uint256 _tokenId) { require(tokenToOwner[_tokenId] != addressZero, "invalidTokenId"); _; } modifier mintingEnabled() { require(isMintingEnabled, "mintDisabled"); _; } modifier transferApproved(uint256 _tokenId) { address tokenOwner = tokenToOwner[_tokenId]; require( tokenOwner == msg.sender || tokenToApproval[_tokenId] == msg.sender || (ownerToOperators[tokenOwner][msg.sender] && tokenOwner != addressZero) , "notApproved" ); _; } modifier canOperate(uint256 _tokenId) { address tokenOwner = tokenToOwner[_tokenId]; require( tokenOwner == msg.sender || (ownerToOperators[tokenOwner][msg.sender] && tokenOwner != addressZero) ,"operationNotApproved" ); _; } modifier notZeroAddress(address _addr) { require(_addr != addressZero, "zeroAddress"); _; } /*************************************************************************** */ /*************************************************************************** */ // Events: // NFT minted event Mint(uint indexed tokenId, address indexed mintedBy, address indexed mintedTo); // ETC is deposited into the contract. event Deposit(address indexed account, uint amount); // ETC is withdrawn from the contract. event Withdraw(address indexed account, uint amount); event MintingEnabled(); event MintingDisabled(); }
[{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"},{"internalType":"address","name":"marketer","type":"address"},{"internalType":"uint256","name":"marketerComission","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"mintedBy","type":"address"},{"indexed":true,"internalType":"address","name":"mintedTo","type":"address"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[],"name":"MintingDisabled","type":"event"},{"anonymous":false,"inputs":[],"name":"MintingEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MINTING_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"_claimETC","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_disableMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_enableMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"_setMintingPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_approved","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"changeBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getNFTPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNotMintedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getUserTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMintingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintingPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"bool","name":"_approved","type":"bool"}],"name":"setApprovalForAll","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":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]