{ "fileName": "ERC721.sol", "contractName": "ERC721UpgradeSafe", "source": "pragma solidity ^0.6.0;\n\nimport \"../../GSN/Context.sol\";\nimport \"./IERC721.sol\";\nimport \"./IERC721Metadata.sol\";\nimport \"./IERC721Enumerable.sol\";\nimport \"./IERC721Receiver.sol\";\nimport \"../../introspection/ERC165.sol\";\nimport \"../../math/SafeMath.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/EnumerableSet.sol\";\nimport \"../../utils/EnumerableMap.sol\";\nimport \"../../utils/Strings.sol\";\nimport \"../../Initializable.sol\";\n\n/**\n * @title ERC721 Non-Fungible Token Standard basic implementation\n * @dev see https://eips.ethereum.org/EIPS/eip-721\n */\ncontract ERC721UpgradeSafe is Initializable, ContextUpgradeSafe, ERC165UpgradeSafe, IERC721, IERC721Metadata, IERC721Enumerable {\n using SafeMath for uint256;\n using Address for address;\n using EnumerableSet for EnumerableSet.UintSet;\n using EnumerableMap for EnumerableMap.UintToAddressMap;\n using Strings for uint256;\n\n // Equals to `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`\n // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`\n bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;\n\n // Mapping from holder address to their (enumerable) set of owned tokens\n mapping (address => EnumerableSet.UintSet) private _holderTokens;\n\n // Enumerable mapping from token ids to their owners\n EnumerableMap.UintToAddressMap private _tokenOwners;\n\n // Mapping from token ID to approved address\n mapping (uint256 => address) private _tokenApprovals;\n\n // Mapping from owner to operator approvals\n mapping (address => mapping (address => bool)) private _operatorApprovals;\n\n // Token name\n string private _name;\n\n // Token symbol\n string private _symbol;\n\n // Optional mapping for token URIs\n mapping(uint256 => string) private _tokenURIs;\n\n // Base URI\n string private _baseURI;\n\n /*\n * bytes4(keccak256('balanceOf(address)')) == 0x70a08231\n * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e\n * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3\n * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc\n * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465\n * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5\n * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd\n * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e\n * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde\n *\n * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^\n * 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd\n */\n bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;\n\n /*\n * bytes4(keccak256('name()')) == 0x06fdde03\n * bytes4(keccak256('symbol()')) == 0x95d89b41\n * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd\n *\n * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f\n */\n bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;\n\n /*\n * bytes4(keccak256('totalSupply()')) == 0x18160ddd\n * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59\n * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7\n *\n * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63\n */\n bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;\n\n\n function __ERC721_init(string memory name, string memory symbol) internal initializer {\n __Context_init_unchained();\n __ERC165_init_unchained();\n __ERC721_init_unchained(name, symbol);\n }\n\n function __ERC721_init_unchained(string memory name, string memory symbol) internal initializer {\n\n\n _name = name;\n _symbol = symbol;\n\n // register the supported interfaces to conform to ERC721 via ERC165\n _registerInterface(_INTERFACE_ID_ERC721);\n _registerInterface(_INTERFACE_ID_ERC721_METADATA);\n _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);\n\n }\n\n\n /**\n * @dev Gets the balance of the specified address.\n * @param owner address to query the balance of\n * @return uint256 representing the amount owned by the passed address\n */\n function balanceOf(address owner) public view override returns (uint256) {\n require(owner != address(0), \"ERC721: balance query for the zero address\");\n\n return _holderTokens[owner].length();\n }\n\n /**\n * @dev Gets the owner of the specified token ID.\n * @param tokenId uint256 ID of the token to query the owner of\n * @return address currently marked as the owner of the given token ID\n */\n function ownerOf(uint256 tokenId) public view override returns (address) {\n return _tokenOwners.get(tokenId, \"ERC721: owner query for nonexistent token\");\n }\n\n /**\n * @dev Gets the token name.\n * @return string representing the token name\n */\n function name() public view override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Gets the token symbol.\n * @return string representing the token symbol\n */\n function symbol() public view override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the URI for a given token ID. May return an empty string.\n *\n * If a base URI is set (via {_setBaseURI}), it is added as a prefix to the\n * token's own URI (via {_setTokenURI}).\n *\n * If there is a base URI but no token URI, the token's ID will be used as\n * its URI when appending it to the base URI. This pattern for autogenerated\n * token URIs can lead to large gas savings.\n *\n * .Examples\n * |===\n * |`_setBaseURI()` |`_setTokenURI()` |`tokenURI()`\n * | \"\"\n * | \"\"\n * | \"\"\n * | \"\"\n * | \"token.uri/123\"\n * | \"token.uri/123\"\n * | \"token.uri/\"\n * | \"123\"\n * | \"token.uri/123\"\n * | \"token.uri/\"\n * | \"\"\n * | \"token.uri/\"\n * |===\n *\n * Requirements:\n *\n * - `tokenId` must exist.\n */\n function tokenURI(uint256 tokenId) public view override returns (string memory) {\n require(_exists(tokenId), \"ERC721Metadata: URI query for nonexistent token\");\n\n string memory _tokenURI = _tokenURIs[tokenId];\n\n // If there is no base URI, return the token URI.\n if (bytes(_baseURI).length == 0) {\n return _tokenURI;\n }\n // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).\n if (bytes(_tokenURI).length > 0) {\n return string(abi.encodePacked(_baseURI, _tokenURI));\n }\n // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.\n return string(abi.encodePacked(_baseURI, tokenId.toString()));\n }\n\n /**\n * @dev Returns the base URI set via {_setBaseURI}. This will be\n * automatically added as a prefix in {tokenURI} to each token's URI, or\n * to the token ID if no specific URI is set for that token ID.\n */\n function baseURI() public view returns (string memory) {\n return _baseURI;\n }\n\n /**\n * @dev Gets the token ID at a given index of the tokens list of the requested owner.\n * @param owner address owning the tokens list to be accessed\n * @param index uint256 representing the index to be accessed of the requested tokens list\n * @return uint256 token ID at the given index of the tokens list owned by the requested address\n */\n function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {\n return _holderTokens[owner].at(index);\n }\n\n /**\n * @dev Gets the total amount of tokens stored by the contract.\n * @return uint256 representing the total amount of tokens\n */\n function totalSupply() public view override returns (uint256) {\n // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds\n return _tokenOwners.length();\n }\n\n /**\n * @dev Gets the token ID at a given index of all the tokens in this contract\n * Reverts if the index is greater or equal to the total number of tokens.\n * @param index uint256 representing the index to be accessed of the tokens list\n * @return uint256 token ID at the given index of the tokens list\n */\n function tokenByIndex(uint256 index) public view override returns (uint256) {\n (uint256 tokenId, ) = _tokenOwners.at(index);\n return tokenId;\n }\n\n /**\n * @dev Approves another address to transfer the given token ID\n * The zero address indicates there is no approved address.\n * There can only be one approved address per token at a given time.\n * Can only be called by the token owner or an approved operator.\n * @param to address to be approved for the given token ID\n * @param tokenId uint256 ID of the token to be approved\n */\n function approve(address to, uint256 tokenId) public virtual override {\n address owner = ownerOf(tokenId);\n require(to != owner, \"ERC721: approval to current owner\");\n\n require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n \"ERC721: approve caller is not owner nor approved for all\"\n );\n\n _approve(to, tokenId);\n }\n\n /**\n * @dev Gets the approved address for a token ID, or zero if no address set\n * Reverts if the token ID does not exist.\n * @param tokenId uint256 ID of the token to query the approval of\n * @return address currently approved for the given token ID\n */\n function getApproved(uint256 tokenId) public view override returns (address) {\n require(_exists(tokenId), \"ERC721: approved query for nonexistent token\");\n\n return _tokenApprovals[tokenId];\n }\n\n /**\n * @dev Sets or unsets the approval of a given operator\n * An operator is allowed to transfer all tokens of the sender on their behalf.\n * @param operator operator address to set the approval\n * @param approved representing the status of the approval to be set\n */\n function setApprovalForAll(address operator, bool approved) public virtual override {\n require(operator != _msgSender(), \"ERC721: approve to caller\");\n\n _operatorApprovals[_msgSender()][operator] = approved;\n emit ApprovalForAll(_msgSender(), operator, approved);\n }\n\n /**\n * @dev Tells whether an operator is approved by a given owner.\n * @param owner owner address which you want to query the approval of\n * @param operator operator address which you want to query the approval of\n * @return bool whether the given operator is approved by the given owner\n */\n function isApprovedForAll(address owner, address operator) public view override returns (bool) {\n return _operatorApprovals[owner][operator];\n }\n\n /**\n * @dev Transfers the ownership of a given token ID to another address.\n * Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n * Requires the msg.sender to be the owner, approved, or operator.\n * @param from current owner of the token\n * @param to address to receive the ownership of the given token ID\n * @param tokenId uint256 ID of the token to be transferred\n */\n function transferFrom(address from, address to, uint256 tokenId) public virtual override {\n //solhint-disable-next-line max-line-length\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n\n _transfer(from, to, tokenId);\n }\n\n /**\n * @dev Safely transfers the ownership of a given token ID to another address\n * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},\n * which is called upon a safe transfer, and return the magic value\n * `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\n * the transfer is reverted.\n * Requires the msg.sender to be the owner, approved, or operator\n * @param from current owner of the token\n * @param to address to receive the ownership of the given token ID\n * @param tokenId uint256 ID of the token to be transferred\n */\n function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {\n safeTransferFrom(from, to, tokenId, \"\");\n }\n\n /**\n * @dev Safely transfers the ownership of a given token ID to another address\n * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},\n * which is called upon a safe transfer, and return the magic value\n * `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\n * the transfer is reverted.\n * Requires the _msgSender() to be the owner, approved, or operator\n * @param from current owner of the token\n * @param to address to receive the ownership of the given token ID\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes data to send along with a safe transfer check\n */\n function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {\n require(_isApprovedOrOwner(_msgSender(), tokenId), \"ERC721: transfer caller is not owner nor approved\");\n _safeTransfer(from, to, tokenId, _data);\n }\n\n /**\n * @dev Safely transfers the ownership of a given token ID to another address\n * If the target address is a contract, it must implement `onERC721Received`,\n * which is called upon a safe transfer, and return the magic value\n * `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\n * the transfer is reverted.\n * Requires the msg.sender to be the owner, approved, or operator\n * @param from current owner of the token\n * @param to address to receive the ownership of the given token ID\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes data to send along with a safe transfer check\n */\n function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {\n _transfer(from, to, tokenId);\n require(_checkOnERC721Received(from, to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Returns whether the specified token exists.\n * @param tokenId uint256 ID of the token to query the existence of\n * @return bool whether the token exists\n */\n function _exists(uint256 tokenId) internal view returns (bool) {\n return _tokenOwners.contains(tokenId);\n }\n\n /**\n * @dev Returns whether the given spender can transfer a given token ID.\n * @param spender address of the spender to query\n * @param tokenId uint256 ID of the token to be transferred\n * @return bool whether the msg.sender is approved for the given token ID,\n * is an operator of the owner, or is the owner of the token\n */\n function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {\n require(_exists(tokenId), \"ERC721: operator query for nonexistent token\");\n address owner = ownerOf(tokenId);\n return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));\n }\n\n /**\n * @dev Internal function to safely mint a new token.\n * Reverts if the given token ID already exists.\n * If the target address is a contract, it must implement `onERC721Received`,\n * which is called upon a safe transfer, and return the magic value\n * `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\n * the transfer is reverted.\n * @param to The address that will own the minted token\n * @param tokenId uint256 ID of the token to be minted\n */\n function _safeMint(address to, uint256 tokenId) internal virtual {\n _safeMint(to, tokenId, \"\");\n }\n\n /**\n * @dev Internal function to safely mint a new token.\n * Reverts if the given token ID already exists.\n * If the target address is a contract, it must implement `onERC721Received`,\n * which is called upon a safe transfer, and return the magic value\n * `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\n * the transfer is reverted.\n * @param to The address that will own the minted token\n * @param tokenId uint256 ID of the token to be minted\n * @param _data bytes data to send along with a safe transfer check\n */\n function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {\n _mint(to, tokenId);\n require(_checkOnERC721Received(address(0), to, tokenId, _data), \"ERC721: transfer to non ERC721Receiver implementer\");\n }\n\n /**\n * @dev Internal function to mint a new token.\n * Reverts if the given token ID already exists.\n * @param to The address that will own the minted token\n * @param tokenId uint256 ID of the token to be minted\n */\n function _mint(address to, uint256 tokenId) internal virtual {\n require(to != address(0), \"ERC721: mint to the zero address\");\n require(!_exists(tokenId), \"ERC721: token already minted\");\n\n _beforeTokenTransfer(address(0), to, tokenId);\n\n _holderTokens[to].add(tokenId);\n\n _tokenOwners.set(tokenId, to);\n\n emit Transfer(address(0), to, tokenId);\n }\n\n /**\n * @dev Internal function to burn a specific token.\n * Reverts if the token does not exist.\n * @param tokenId uint256 ID of the token being burned\n */\n function _burn(uint256 tokenId) internal virtual {\n address owner = ownerOf(tokenId);\n\n _beforeTokenTransfer(owner, address(0), tokenId);\n\n // Clear approvals\n _approve(address(0), tokenId);\n\n // Clear metadata (if any)\n if (bytes(_tokenURIs[tokenId]).length != 0) {\n delete _tokenURIs[tokenId];\n }\n\n _holderTokens[owner].remove(tokenId);\n\n _tokenOwners.remove(tokenId);\n\n emit Transfer(owner, address(0), tokenId);\n }\n\n /**\n * @dev Internal function to transfer ownership of a given token ID to another address.\n * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n * @param from current owner of the token\n * @param to address to receive the ownership of the given token ID\n * @param tokenId uint256 ID of the token to be transferred\n */\n function _transfer(address from, address to, uint256 tokenId) internal virtual {\n require(ownerOf(tokenId) == from, \"ERC721: transfer of token that is not own\");\n require(to != address(0), \"ERC721: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, tokenId);\n\n // Clear approvals from the previous owner\n _approve(address(0), tokenId);\n\n _holderTokens[from].remove(tokenId);\n _holderTokens[to].add(tokenId);\n\n _tokenOwners.set(tokenId, to);\n\n emit Transfer(from, to, tokenId);\n }\n\n /**\n * @dev Internal function to set the token URI for a given token.\n *\n * Reverts if the token ID does not exist.\n *\n * TIP: If all token IDs share a prefix (for example, if your URIs look like\n * `https://api.myproject.com/token/`), use {_setBaseURI} to store\n * it and save gas.\n */\n function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {\n require(_exists(tokenId), \"ERC721Metadata: URI set of nonexistent token\");\n _tokenURIs[tokenId] = _tokenURI;\n }\n\n /**\n * @dev Internal function to set the base URI for all token IDs. It is\n * automatically added as a prefix to the value returned in {tokenURI},\n * or to the token ID if {tokenURI} is empty.\n */\n function _setBaseURI(string memory baseURI_) internal virtual {\n _baseURI = baseURI_;\n }\n\n /**\n * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n * The call is not executed if the target address is not a contract.\n *\n * @param from address representing the previous owner of the given token ID\n * @param to target address that will receive the tokens\n * @param tokenId uint256 ID of the token to be transferred\n * @param _data bytes optional data to send along with the call\n * @return bool whether the call correctly returned the expected magic value\n */\n function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)\n private returns (bool)\n {\n if (!to.isContract()) {\n return true;\n }\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(\n IERC721Receiver(to).onERC721Received.selector,\n _msgSender(),\n from,\n tokenId,\n _data\n ));\n if (!success) {\n if (returndata.length > 0) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(\"ERC721: transfer to non ERC721Receiver implementer\");\n }\n } else {\n bytes4 retval = abi.decode(returndata, (bytes4));\n return (retval == _ERC721_RECEIVED);\n }\n }\n\n function _approve(address to, uint256 tokenId) private {\n _tokenApprovals[tokenId] = to;\n emit Approval(ownerOf(tokenId), to, tokenId);\n }\n\n /**\n * @dev Hook that is called before any token transfer. This includes minting\n * and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, ``from``'s `tokenId` will be\n * transferred to `to`.\n * - when `from` is zero, `tokenId` will be minted for `to`.\n * - when `to` is zero, ``from``'s `tokenId` will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }\n\n uint256[41] private __gap;\n}\n", "sourcePath": "contracts/token/ERC721/ERC721.sol", "sourceMap": "562:21971:86:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;562:21971:86;;;;;;;", "deployedSourceMap": "562:21971:86:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;562:21971:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;1103:140:12;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;1103:140:12;-1:-1:-1;;;;;;1103:140:12;;:::i;:::-;;;;;;;;;;;;;;;;;;5028:90:86;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;5028:90:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9688:209;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;9688:209:86;;:::i;:::-;;;;-1:-1:-1;;;;;9688:209:86;;;;;;;;;;;;;;9022:381;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;9022:381:86;;;;;;;;:::i;:::-;;7902:200;;;:::i;:::-;;;;;;;;;;;;;;;;11399:300;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;11399:300:86;;;;;;;;;;;;;;;;;:::i;7597:152::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;7597:152:86;;;;;;;;:::i;12348:149::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;12348:149:86;;;;;;;;;;;;;;;;;:::i;8440:161::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;8440:161:86;;:::i;4756:167::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4756:167:86;;:::i;7136:87::-;;;:::i;4326:211::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4326:211:86;-1:-1:-1;;;;;4326:211:86;;:::i;5227:94::-;;;:::i;10196:290::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;10196:290:86;;;;;;;;;;:::i;13220:282::-;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;13220:282:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;13220:282:86;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;13220:282:86;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;13220:282:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;13220:282:86;;-1:-1:-1;13220:282:86;;-1:-1:-1;;;;;13220:282:86:i;6164:740::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;6164:740:86;;:::i;10808:154::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;10808:154:86;;;;;;;;;;:::i;1103:140:12:-;-1:-1:-1;;;;;;1203:33:12;;1180:4;1203:33;;;:20;:33;;;;;;;;1103:140;;;;:::o;5028:90:86:-;5106:5;5099:12;;;;;;;;-1:-1:-1;;5099:12:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5074:13;;5099:12;;5106:5;;5099:12;;5106:5;5099:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5028:90;:::o;9688:209::-;9756:7;9783:16;9791:7;9783;:16::i;:::-;9775:73;;;;-1:-1:-1;;;9775:73:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9866:24:86;;;;:15;:24;;;;;;-1:-1:-1;;;;;9866:24:86;;9688:209::o;9022:381::-;9102:13;9118:16;9126:7;9118;:16::i;:::-;9102:32;;9158:5;-1:-1:-1;;;;;9152:11:86;:2;-1:-1:-1;;;;;9152:11:86;;;9144:57;;;;-1:-1:-1;;;9144:57:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9236:5;-1:-1:-1;;;;;9220:21:86;:12;:10;:12::i;:::-;-1:-1:-1;;;;;9220:21:86;;:62;;;;9245:37;9262:5;9269:12;:10;:12::i;:::-;9245:16;:37::i;:::-;9212:152;;;;-1:-1:-1;;;9212:152:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9375:21;9384:2;9388:7;9375:8;:21::i;:::-;9022:381;;;:::o;7902:200::-;7955:7;8074:21;:12;:19;:21::i;:::-;8067:28;;7902:200;:::o;11399:300::-;11558:41;11577:12;:10;:12::i;:::-;11591:7;11558:18;:41::i;:::-;11550:103;;;;-1:-1:-1;;;11550:103:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11664:28;11674:4;11680:2;11684:7;11664:9;:28::i;7597:152::-;-1:-1:-1;;;;;7712:20:86;;7686:7;7712:20;;;:13;:20;;;;;:30;;7736:5;7712:30;:23;:30;:::i;:::-;7705:37;;7597:152;;;;;:::o;12348:149::-;12451:39;12468:4;12474:2;12478:7;12451:39;;;;;;;;;;;;:16;:39::i;8440:161::-;8507:7;;8548:22;:12;8564:5;8548:22;:15;:22;:::i;:::-;-1:-1:-1;8526:44:86;8440:161;-1:-1:-1;;;8440:161:86:o;4756:167::-;4820:7;4846:70;4863:7;4846:70;;;;;;;;;;;;;;;;;:12;;:70;;:16;:70;:::i;7136:87::-;7208:8;7201:15;;;;;;;;-1:-1:-1;;7201:15:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7176:13;;7201:15;;7208:8;;7201:15;;7208:8;7201:15;;;;;;;;;;;;;;;;;;;;;;;;4326:211;4390:7;-1:-1:-1;;;;;4417:19:86;;4409:74;;;;-1:-1:-1;;;4409:74:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;4501:20:86;;;;;;:13;:20;;;;;:29;;:27;:29::i;5227:94::-;5307:7;5300:14;;;;;;;;-1:-1:-1;;5300:14:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5275:13;;5300:14;;5307:7;;5300:14;;5307:7;5300:14;;;;;;;;;;;;;;;;;;;;;;;;10196:290;10310:12;:10;:12::i;:::-;-1:-1:-1;;;;;10298:24:86;:8;-1:-1:-1;;;;;10298:24:86;;;10290:62;;;;;-1:-1:-1;;;10290:62:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;10408:8;10363:18;:32;10382:12;:10;:12::i;:::-;-1:-1:-1;;;;;10363:32:86;;;;;;;;;;;;;;;;;-1:-1:-1;10363:32:86;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;10363:53:86;;;;;;;;;;;10446:12;:10;:12::i;:::-;10431:48;;;;;;;;;;-1:-1:-1;;;;;10431:48:86;;;;;;;;;;;;;;10196:290;;:::o;13220:282::-;13351:41;13370:12;:10;:12::i;:::-;13384:7;13351:18;:41::i;:::-;13343:103;;;;-1:-1:-1;;;13343:103:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13456:39;13470:4;13476:2;13480:7;13489:5;13456:13;:39::i;:::-;13220:282;;;;:::o;6164:740::-;6229:13;6262:16;6270:7;6262;:16::i;:::-;6254:76;;;;-1:-1:-1;;;6254:76:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6367:19;;;;:10;:19;;;;;;;;;6341:45;;;;;;-1:-1:-1;;6341:45:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;6367:19;6341:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6465:8:86;6459:22;6341:45;;-1:-1:-1;;;;6459:22:86;-1:-1:-1;;6459:22:86;;;;;;;;;;;6455:74;;6509:9;-1:-1:-1;6502:16:86;;6455:74;6631:23;;:27;6627:110;;6705:8;6715:9;6688:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6688:37:86;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;6688:37:86;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;6688:37:86;;;6674:52;;;;;6627:110;6867:8;6877:18;:7;:16;:18::i;:::-;6850:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6850:46:86;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;6850:46:86;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;6850:46:86;;;6836:61;;;6164:740;;;:::o;10808:154::-;-1:-1:-1;;;;;10920:25:86;;;10897:4;10920:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;10808:154::o;14671:117::-;14728:4;14751:30;:12;14773:7;14751:30;:21;:30;:::i;931:104:0:-;1018:10;931:104;:::o;21695:155:86:-;21760:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;21760:29:86;-1:-1:-1;;;;;21760:29:86;;;;;;;;:24;;21813:16;21760:24;21813:7;:16::i;:::-;-1:-1:-1;;;;;21804:39:86;;;;;;;;;;;21695:155;;:::o;6990:121:102:-;7059:7;7085:19;7093:3;7085:7;:19::i;15149:329:86:-;15234:4;15258:16;15266:7;15258;:16::i;:::-;15250:73;;;;-1:-1:-1;;;15250:73:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15333:13;15349:16;15357:7;15349;:16::i;:::-;15333:32;;15394:5;-1:-1:-1;;;;;15383:16:86;:7;-1:-1:-1;;;;;15383:16:86;;:51;;;;15427:7;-1:-1:-1;;;;;15403:31:86;:20;15415:7;15403:11;:20::i;:::-;-1:-1:-1;;;;;15403:31:86;;15383:51;:87;;;;15438:32;15455:5;15462:7;15438:16;:32::i;:::-;15375:96;15149:329;-1:-1:-1;;;;15149:329:86:o;18661:559::-;18778:4;-1:-1:-1;;;;;18758:24:86;:16;18766:7;18758;:16::i;:::-;-1:-1:-1;;;;;18758:24:86;;18750:78;;;;-1:-1:-1;;;18750:78:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18846:16:86;;18838:65;;;;-1:-1:-1;;;18838:65:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18914:39;18935:4;18941:2;18945:7;18914:20;:39::i;:::-;19015:29;19032:1;19036:7;19015:8;:29::i;:::-;-1:-1:-1;;;;;19055:19:86;;;;;;:13;:19;;;;;:35;;19082:7;19055:35;:26;:35;:::i;:::-;-1:-1:-1;;;;;;19100:17:86;;;;;;:13;:17;;;;;:30;;19122:7;19100:30;:21;:30;:::i;:::-;-1:-1:-1;19141:29:86;:12;19158:7;19167:2;19141:29;:16;:29;:::i;:::-;;19205:7;19201:2;-1:-1:-1;;;;;19186:27:86;19195:4;-1:-1:-1;;;;;19186:27:86;;;;;;;;;;;18661:559;;;:::o;7616:135:103:-;7687:7;7721:22;7725:3;7737:5;7721:3;:22::i;7439:224:102:-;7519:7;;;;7578:22;7582:3;7594:5;7578:3;:22::i;:::-;7547:53;;;;-1:-1:-1;7439:224:102;-1:-1:-1;;;;;7439:224:102:o;8082:202::-;8189:7;8231:44;8236:3;8256;8262:12;8231:4;:44::i;:::-;8223:53;-1:-1:-1;8082:202:102;;;;;;:::o;14207:269:86:-;14320:28;14330:4;14336:2;14340:7;14320:9;:28::i;:::-;14366:48;14389:4;14395:2;14399:7;14408:5;14366:22;:48::i;:::-;14358:111;;;;-1:-1:-1;;;14358:111:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;169:723:107;225:13;442:10;438:51;;-1:-1:-1;468:10:107;;;;;;;;;;;;-1:-1:-1;;;468:10:107;;;;;;438:51;513:5;498:12;552:75;559:9;;552:75;;584:8;;614:2;606:10;;;;552:75;;;636:19;668:6;658:17;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;658:17:107;;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;108:14;658:17:107;87:42:-1;143:17;;-1:-1;658:17:107;-1:-1:-1;728:5:107;;-1:-1:-1;636:39:107;-1:-1:-1;;;701:10:107;;743:112;750:9;;743:112;;816:2;809:4;:9;804:2;:14;793:27;;775:6;782:7;;;;;;;775:15;;;;;;;;;;;:45;-1:-1:-1;;;;;775:45:107;;;;;;;;-1:-1:-1;842:2:107;834:10;;;;743:112;;;-1:-1:-1;878:6:107;169:723;-1:-1:-1;;;;169:723:107:o;6758:149:102:-;6842:4;6865:35;6875:3;6895;6865:9;:35::i;4450:108::-;4532:19;;4450:108::o;6731:135:103:-;6801:4;6824:35;6832:3;6852:5;6824:7;:35::i;6434:129::-;6501:4;6524:32;6529:3;6549:5;6524:4;:32::i;6206:174:102:-;6295:4;6318:55;6323:3;6343;-1:-1:-1;;;;;6357:14:102;;6318:4;:55::i;4390:201:103:-;4484:18;;4457:7;;4484:26;-1:-1:-1;4476:73:103;;;;-1:-1:-1;;;4476:73:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4566:3;:11;;4578:5;4566:18;;;;;;;;;;;;;;;;4559:25;;4390:201;;;;:::o;4901:274:102:-;5004:19;;4968:7;;;;5004:27;-1:-1:-1;4996:74:102;;;;-1:-1:-1;;;4996:74:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5081:22;5106:3;:12;;5119:5;5106:19;;;;;;;;;;;;;;;;;;5081:44;;5143:5;:10;;;5155:5;:12;;;5135:33;;;;;4901:274;;;;;:::o;5582:315::-;5676:7;5714:17;;;:12;;;:17;;;;;;5764:12;5749:13;5741:36;;;;-1:-1:-1;;;5741:36:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;5741:36:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5830:3;:12;;5854:1;5843:8;:12;5830:26;;;;;;;;;;;;;;;;;;:33;;;5823:40;;;5582:315;;;;;:::o;20639:1050:86:-;20759:4;20784:15;:2;-1:-1:-1;;;;;20784:13:86;;:15::i;:::-;20779:58;;-1:-1:-1;20822:4:86;20815:11;;20779:58;20906:12;20920:23;-1:-1:-1;;;;;20947:7:86;;-1:-1:-1;;;21050:12:86;:10;:12::i;:::-;21076:4;21094:7;21115:5;20955:175;;;;;;-1:-1:-1;;;;;20955:175:86;-1:-1:-1;;;;;20955:175:86;;;;;;-1:-1:-1;;;;;20955:175:86;-1:-1:-1;;;;;20955:175:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;20955:175:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20955:175:86;;;-1:-1:-1;;26:21;;;22:32;6:49;;20955:175:86;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;20955:175:86;;;179:29:-1;;;;160:49;;20947:184:86;;;20955:175;;20947:184;;-1:-1:-1;20947:184:86;;-1:-1:-1;25:18;-1:-1;20947:184:86;-1:-1:-1;20947:184:86;;-1:-1:-1;20947:184:86;;-1:-1:-1;25:18;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;20947:184:86;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;20905:226:86;;;;21146:7;21141:542;;21173:17;;:21;21169:376;;21338:10;21332:17;21398:15;21385:10;21381:2;21377:19;21370:44;21287:145;21470:60;;-1:-1:-1;;;21470:60:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21141:542;21575:13;21602:10;21591:32;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;21591:32:86;-1:-1:-1;;;;;;21645:26:86;-1:-1:-1;;;21645:26:86;;-1:-1:-1;21637:35:86;;-1:-1:-1;;;21637:35:86;4237:123:102;4308:4;4331:17;;;:12;;;;;:17;;;;;;:22;;;4237:123::o;2150:1512:103:-;2216:4;2353:19;;;:12;;;:19;;;;;;2387:15;;2383:1273;;2816:18;;-1:-1:-1;;2768:14:103;;;;2816:22;;;;2744:21;;2816:3;;:22;;3098;;;;;;;;;;;;;;3078:42;;3241:9;3212:3;:11;;3224:13;3212:26;;;;;;;;;;;;;;;;;;;:38;;;;3316:23;;;3358:1;3316:12;;;:23;;;;;;3342:17;;;3316:43;;3465:17;;3316:3;;3465:17;;;;;;;;;;;;;;;;;;;;;;3557:3;:12;;:19;3570:5;3557:19;;;;;;;;;;;3550:26;;;3598:4;3591:11;;;;;;;;2383:1273;3640:5;3633:12;;;;;1578:404;1641:4;1662:21;1672:3;1677:5;1662:9;:21::i;:::-;1657:319;;-1:-1:-1;27:10;;39:1;23:18;;;45:23;;1699:11:103;:23;;;;;;;;;;;;;1879:18;;1857:19;;;:12;;;:19;;;;;;:40;;;;1911:11;;1657:319;-1:-1:-1;1960:5:103;1953:12;;1795:678:102;1871:4;2004:17;;;:12;;;:17;;;;;;2036:13;2032:435;;-1:-1:-1;;2120:38:102;;;;;;;;;;;;;;;;;;27:10:-1;;39:1;23:18;;;45:23;;2102:12:102;:57;;;;;;;;;;;;;;;;;;;;;;;;2314:19;;2294:17;;;:12;;;:17;;;;;;;:39;2347:11;;2032:435;2425:5;2389:3;:12;;2413:1;2402:8;:12;2389:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;2451:5;2444:12;;;;;685:610:98;745:4;1206:20;;1051:66;1245:23;;;;;;:42;;-1:-1:-1;;1272:15:98;;;1237:51;-1:-1:-1;;685:610:98:o", "abi": [ { "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": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": true, "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], "name": "Transfer", "type": "event" }, { "inputs": [ { "internalType": "address", "name": "to", "type": "address" }, { "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], "name": "approve", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "owner", "type": "address" } ], "name": "balanceOf", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "baseURI", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], "name": "getApproved", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "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": "name", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "tokenId", "type": "uint256" } ], "name": "ownerOf", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "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": "nonpayable", "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": "nonpayable", "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": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "index", "type": "uint256" } ], "name": "tokenByIndex", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "owner", "type": "address" }, { "internalType": "uint256", "name": "index", "type": "uint256" } ], "name": "tokenOfOwnerByIndex", "outputs": [ { "internalType": "uint256", "name": "", "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": "nonpayable", "type": "function" } ], "ast": { "absolutePath": "contracts/token/ERC721/ERC721.sol", "exportedSymbols": { "ERC721UpgradeSafe": [ 12203 ] }, "id": 12204, "nodeType": "SourceUnit", "nodes": [ { "id": 11227, "literals": [ "solidity", "^", "0.6", ".0" ], "nodeType": "PragmaDirective", "src": "0:23:86" }, { "absolutePath": "contracts/GSN/Context.sol", "file": "../../GSN/Context.sol", "id": 11228, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 45, "src": "25:31:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/token/ERC721/IERC721.sol", "file": "./IERC721.sol", "id": 11229, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 12485, "src": "57:23:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/token/ERC721/IERC721Metadata.sol", "file": "./IERC721Metadata.sol", "id": 11230, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 12537, "src": "81:31:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/token/ERC721/IERC721Enumerable.sol", "file": "./IERC721Enumerable.sol", "id": 11231, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 12513, "src": "113:33:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/token/ERC721/IERC721Receiver.sol", "file": "./IERC721Receiver.sol", "id": 11232, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 12555, "src": "147:31:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/introspection/ERC165.sol", "file": "../../introspection/ERC165.sol", "id": 11233, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 2512, "src": "179:40:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/math/SafeMath.sol", "file": "../../math/SafeMath.sol", "id": 11234, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 3153, "src": "220:33:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/utils/Address.sol", "file": "../../utils/Address.sol", "id": 11235, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 13938, "src": "254:33:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/utils/EnumerableSet.sol", "file": "../../utils/EnumerableSet.sol", "id": 11236, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 15033, "src": "288:39:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/utils/EnumerableMap.sol", "file": "../../utils/EnumerableMap.sol", "id": 11237, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 14638, "src": "328:39:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/utils/Strings.sol", "file": "../../utils/Strings.sol", "id": 11238, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 15444, "src": "368:33:86", "symbolAliases": [], "unitAlias": "" }, { "absolutePath": "contracts/Initializable.sol", "file": "../../Initializable.sol", "id": 11239, "nodeType": "ImportDirective", "scope": 12204, "sourceUnit": 1408, "src": "402:33:86", "symbolAliases": [], "unitAlias": "" }, { "abstract": false, "baseContracts": [ { "arguments": null, "baseName": { "contractScope": null, "id": 11241, "name": "Initializable", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 1407, "src": "592:13:86", "typeDescriptions": { "typeIdentifier": "t_contract$_Initializable_$1407", "typeString": "contract Initializable" } }, "id": 11242, "nodeType": "InheritanceSpecifier", "src": "592:13:86" }, { "arguments": null, "baseName": { "contractScope": null, "id": 11243, "name": "ContextUpgradeSafe", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 44, "src": "607:18:86", "typeDescriptions": { "typeIdentifier": "t_contract$_ContextUpgradeSafe_$44", "typeString": "contract ContextUpgradeSafe" } }, "id": 11244, "nodeType": "InheritanceSpecifier", "src": "607:18:86" }, { "arguments": null, "baseName": { "contractScope": null, "id": 11245, "name": "ERC165UpgradeSafe", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 2511, "src": "627:17:86", "typeDescriptions": { "typeIdentifier": "t_contract$_ERC165UpgradeSafe_$2511", "typeString": "contract ERC165UpgradeSafe" } }, "id": 11246, "nodeType": "InheritanceSpecifier", "src": "627:17:86" }, { "arguments": null, "baseName": { "contractScope": null, "id": 11247, "name": "IERC721", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 12484, "src": "646:7:86", "typeDescriptions": { "typeIdentifier": "t_contract$_IERC721_$12484", "typeString": "contract IERC721" } }, "id": 11248, "nodeType": "InheritanceSpecifier", "src": "646:7:86" }, { "arguments": null, "baseName": { "contractScope": null, "id": 11249, "name": "IERC721Metadata", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 12536, "src": "655:15:86", "typeDescriptions": { "typeIdentifier": "t_contract$_IERC721Metadata_$12536", "typeString": "contract IERC721Metadata" } }, "id": 11250, "nodeType": "InheritanceSpecifier", "src": "655:15:86" }, { "arguments": null, "baseName": { "contractScope": null, "id": 11251, "name": "IERC721Enumerable", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 12512, "src": "672:17:86", "typeDescriptions": { "typeIdentifier": "t_contract$_IERC721Enumerable_$12512", "typeString": "contract IERC721Enumerable" } }, "id": 11252, "nodeType": "InheritanceSpecifier", "src": "672:17:86" } ], "contractDependencies": [ 44, 1407, 2511, 2779, 12484, 12512, 12536 ], "contractKind": "contract", "documentation": { "id": 11240, "nodeType": "StructuredDocumentation", "src": "437:124:86", "text": "@title ERC721 Non-Fungible Token Standard basic implementation\n@dev see https://eips.ethereum.org/EIPS/eip-721" }, "fullyImplemented": true, "id": 12203, "linearizedBaseContracts": [ 12203, 12512, 12536, 12484, 2511, 2779, 44, 1407 ], "name": "ERC721UpgradeSafe", "nodeType": "ContractDefinition", "nodes": [ { "id": 11255, "libraryName": { "contractScope": null, "id": 11253, "name": "SafeMath", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 3152, "src": "702:8:86", "typeDescriptions": { "typeIdentifier": "t_contract$_SafeMath_$3152", "typeString": "library SafeMath" } }, "nodeType": "UsingForDirective", "src": "696:27:86", "typeName": { "id": 11254, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "715:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } }, { "id": 11258, "libraryName": { "contractScope": null, "id": 11256, "name": "Address", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 13937, "src": "734:7:86", "typeDescriptions": { "typeIdentifier": "t_contract$_Address_$13937", "typeString": "library Address" } }, "nodeType": "UsingForDirective", "src": "728:26:86", "typeName": { "id": 11257, "name": "address", "nodeType": "ElementaryTypeName", "src": "746:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } }, { "id": 11261, "libraryName": { "contractScope": null, "id": 11259, "name": "EnumerableSet", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 15032, "src": "765:13:86", "typeDescriptions": { "typeIdentifier": "t_contract$_EnumerableSet_$15032", "typeString": "library EnumerableSet" } }, "nodeType": "UsingForDirective", "src": "759:46:86", "typeName": { "contractScope": null, "id": 11260, "name": "EnumerableSet.UintSet", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 14937, "src": "783:21:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage_ptr", "typeString": "struct EnumerableSet.UintSet" } } }, { "id": 11264, "libraryName": { "contractScope": null, "id": 11262, "name": "EnumerableMap", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 14637, "src": "816:13:86", "typeDescriptions": { "typeIdentifier": "t_contract$_EnumerableMap_$14637", "typeString": "library EnumerableMap" } }, "nodeType": "UsingForDirective", "src": "810:55:86", "typeName": { "contractScope": null, "id": 11263, "name": "EnumerableMap.UintToAddressMap", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 14462, "src": "834:30:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage_ptr", "typeString": "struct EnumerableMap.UintToAddressMap" } } }, { "id": 11267, "libraryName": { "contractScope": null, "id": 11265, "name": "Strings", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 15443, "src": "876:7:86", "typeDescriptions": { "typeIdentifier": "t_contract$_Strings_$15443", "typeString": "library Strings" } }, "nodeType": "UsingForDirective", "src": "870:26:86", "typeName": { "id": 11266, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "888:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } }, { "constant": true, "id": 11270, "mutability": "constant", "name": "_ERC721_RECEIVED", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1074:53:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "typeName": { "id": 11268, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "1074:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "value": { "argumentTypes": null, "hexValue": "30783135306237613032", "id": 11269, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "1117:10:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_353073666_by_1", "typeString": "int_const 353073666" }, "value": "0x150b7a02" }, "visibility": "private" }, { "constant": false, "id": 11274, "mutability": "mutable", "name": "_holderTokens", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1211:64:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet)" }, "typeName": { "id": 11273, "keyType": { "id": 11271, "name": "address", "nodeType": "ElementaryTypeName", "src": "1220:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "Mapping", "src": "1211:42:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet)" }, "valueType": { "contractScope": null, "id": 11272, "name": "EnumerableSet.UintSet", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 14937, "src": "1231:21:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage_ptr", "typeString": "struct EnumerableSet.UintSet" } } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11276, "mutability": "mutable", "name": "_tokenOwners", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1339:51:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap" }, "typeName": { "contractScope": null, "id": 11275, "name": "EnumerableMap.UintToAddressMap", "nodeType": "UserDefinedTypeName", "referencedDeclaration": 14462, "src": "1339:30:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage_ptr", "typeString": "struct EnumerableMap.UintToAddressMap" } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11280, "mutability": "mutable", "name": "_tokenApprovals", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1446:52:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_address_$", "typeString": "mapping(uint256 => address)" }, "typeName": { "id": 11279, "keyType": { "id": 11277, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "1455:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "Mapping", "src": "1446:28:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_address_$", "typeString": "mapping(uint256 => address)" }, "valueType": { "id": 11278, "name": "address", "nodeType": "ElementaryTypeName", "src": "1466:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11286, "mutability": "mutable", "name": "_operatorApprovals", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1553:73:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_address_$_t_bool_$_$", "typeString": "mapping(address => mapping(address => bool))" }, "typeName": { "id": 11285, "keyType": { "id": 11281, "name": "address", "nodeType": "ElementaryTypeName", "src": "1562:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "Mapping", "src": "1553:46:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_address_$_t_bool_$_$", "typeString": "mapping(address => mapping(address => bool))" }, "valueType": { "id": 11284, "keyType": { "id": 11282, "name": "address", "nodeType": "ElementaryTypeName", "src": "1582:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "Mapping", "src": "1573:25:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", "typeString": "mapping(address => bool)" }, "valueType": { "id": 11283, "name": "bool", "nodeType": "ElementaryTypeName", "src": "1593:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } } } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11288, "mutability": "mutable", "name": "_name", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1651:20:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string" }, "typeName": { "id": 11287, "name": "string", "nodeType": "ElementaryTypeName", "src": "1651:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11290, "mutability": "mutable", "name": "_symbol", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1698:22:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string" }, "typeName": { "id": 11289, "name": "string", "nodeType": "ElementaryTypeName", "src": "1698:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11294, "mutability": "mutable", "name": "_tokenURIs", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1766:45:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string)" }, "typeName": { "id": 11293, "keyType": { "id": 11291, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "1774:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "Mapping", "src": "1766:26:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string)" }, "valueType": { "id": 11292, "name": "string", "nodeType": "ElementaryTypeName", "src": "1785:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } } }, "value": null, "visibility": "private" }, { "constant": false, "id": 11296, "mutability": "mutable", "name": "_baseURI", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "1834:23:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string" }, "typeName": { "id": 11295, "name": "string", "nodeType": "ElementaryTypeName", "src": "1834:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "private" }, { "constant": true, "id": 11299, "mutability": "constant", "name": "_INTERFACE_ID_ERC721", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "2732:57:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "typeName": { "id": 11297, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "2732:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "value": { "argumentTypes": null, "hexValue": "30783830616335386364", "id": 11298, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "2779:10:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_2158778573_by_1", "typeString": "int_const 2158778573" }, "value": "0x80ac58cd" }, "visibility": "private" }, { "constant": true, "id": 11302, "mutability": "constant", "name": "_INTERFACE_ID_ERC721_METADATA", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "3055:66:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "typeName": { "id": 11300, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "3055:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "value": { "argumentTypes": null, "hexValue": "30783562356531333966", "id": 11301, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "3111:10:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_1532892063_by_1", "typeString": "int_const 1532892063" }, "value": "0x5b5e139f" }, "visibility": "private" }, { "constant": true, "id": 11305, "mutability": "constant", "name": "_INTERFACE_ID_ERC721_ENUMERABLE", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "3426:68:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "typeName": { "id": 11303, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "3426:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "value": { "argumentTypes": null, "hexValue": "30783738306539643633", "id": 11304, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "3484:10:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_2014223715_by_1", "typeString": "int_const 2014223715" }, "value": "0x780e9d63" }, "visibility": "private" }, { "body": { "id": 11325, "nodeType": "Block", "src": "3588:125:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11314, "name": "__Context_init_unchained", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 19, "src": "3598:24:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$", "typeString": "function ()" } }, "id": 11315, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "3598:26:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11316, "nodeType": "ExpressionStatement", "src": "3598:26:86" }, { "expression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11317, "name": "__ERC165_init_unchained", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 2472, "src": "3634:23:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$__$returns$__$", "typeString": "function ()" } }, "id": 11318, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "3634:25:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11319, "nodeType": "ExpressionStatement", "src": "3634:25:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11321, "name": "name", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11307, "src": "3693:4:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, { "argumentTypes": null, "id": 11322, "name": "symbol", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11309, "src": "3699:6:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" }, { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } ], "id": 11320, "name": "__ERC721_init_unchained", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11356, "src": "3669:23:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_string_memory_ptr_$_t_string_memory_ptr_$returns$__$", "typeString": "function (string memory,string memory)" } }, "id": 11323, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "3669:37:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11324, "nodeType": "ExpressionStatement", "src": "3669:37:86" } ] }, "documentation": null, "id": 11326, "implemented": true, "kind": "function", "modifiers": [ { "arguments": null, "id": 11312, "modifierName": { "argumentTypes": null, "id": 11311, "name": "initializer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 1380, "src": "3576:11:86", "typeDescriptions": { "typeIdentifier": "t_modifier$__$", "typeString": "modifier ()" } }, "nodeType": "ModifierInvocation", "src": "3576:11:86" } ], "name": "__ERC721_init", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11310, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11307, "mutability": "mutable", "name": "name", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11326, "src": "3525:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11306, "name": "string", "nodeType": "ElementaryTypeName", "src": "3525:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11309, "mutability": "mutable", "name": "symbol", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11326, "src": "3545:20:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11308, "name": "string", "nodeType": "ElementaryTypeName", "src": "3545:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "3524:42:86" }, "returnParameters": { "id": 11313, "nodeType": "ParameterList", "parameters": [], "src": "3588:0:86" }, "scope": 12203, "src": "3502:211:86", "stateMutability": "nonpayable", "virtual": false, "visibility": "internal" }, { "body": { "id": 11355, "nodeType": "Block", "src": "3815:306:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11337, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "id": 11335, "name": "_name", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11288, "src": "3827:5:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 11336, "name": "name", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11328, "src": "3835:4:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "src": "3827:12:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "id": 11338, "nodeType": "ExpressionStatement", "src": "3827:12:86" }, { "expression": { "argumentTypes": null, "id": 11341, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "id": 11339, "name": "_symbol", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11290, "src": "3849:7:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 11340, "name": "symbol", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11330, "src": "3859:6:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "src": "3849:16:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "id": 11342, "nodeType": "ExpressionStatement", "src": "3849:16:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11344, "name": "_INTERFACE_ID_ERC721", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11299, "src": "3972:20:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } ], "id": 11343, "name": "_registerInterface", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 2506, "src": "3953:18:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_bytes4_$returns$__$", "typeString": "function (bytes4)" } }, "id": 11345, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "3953:40:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11346, "nodeType": "ExpressionStatement", "src": "3953:40:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11348, "name": "_INTERFACE_ID_ERC721_METADATA", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11302, "src": "4022:29:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } ], "id": 11347, "name": "_registerInterface", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 2506, "src": "4003:18:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_bytes4_$returns$__$", "typeString": "function (bytes4)" } }, "id": 11349, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4003:49:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11350, "nodeType": "ExpressionStatement", "src": "4003:49:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11352, "name": "_INTERFACE_ID_ERC721_ENUMERABLE", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11305, "src": "4081:31:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } ], "id": 11351, "name": "_registerInterface", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 2506, "src": "4062:18:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_bytes4_$returns$__$", "typeString": "function (bytes4)" } }, "id": 11353, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4062:51:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11354, "nodeType": "ExpressionStatement", "src": "4062:51:86" } ] }, "documentation": null, "id": 11356, "implemented": true, "kind": "function", "modifiers": [ { "arguments": null, "id": 11333, "modifierName": { "argumentTypes": null, "id": 11332, "name": "initializer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 1380, "src": "3803:11:86", "typeDescriptions": { "typeIdentifier": "t_modifier$__$", "typeString": "modifier ()" } }, "nodeType": "ModifierInvocation", "src": "3803:11:86" } ], "name": "__ERC721_init_unchained", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11331, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11328, "mutability": "mutable", "name": "name", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11356, "src": "3752:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11327, "name": "string", "nodeType": "ElementaryTypeName", "src": "3752:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11330, "mutability": "mutable", "name": "symbol", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11356, "src": "3772:20:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11329, "name": "string", "nodeType": "ElementaryTypeName", "src": "3772:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "3751:42:86" }, "returnParameters": { "id": 11334, "nodeType": "ParameterList", "parameters": [], "src": "3815:0:86" }, "scope": 12203, "src": "3719:402:86", "stateMutability": "nonpayable", "virtual": false, "visibility": "internal" }, { "baseFunctions": [ 12414 ], "body": { "id": 11381, "nodeType": "Block", "src": "4399:138:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11371, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 11366, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11359, "src": "4417:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11369, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "4434:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11368, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "4426:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11367, "name": "address", "nodeType": "ElementaryTypeName", "src": "4426:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11370, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4426:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "src": "4417:19:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a2062616c616e636520717565727920666f7220746865207a65726f2061646472657373", "id": 11372, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "4438:44:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_7395d4d3901c50cdfcab223d072f9aa36241df5d883e62cbf147ee1b05a9e6ba", "typeString": "literal_string \"ERC721: balance query for the zero address\"" }, "value": "ERC721: balance query for the zero address" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_7395d4d3901c50cdfcab223d072f9aa36241df5d883e62cbf147ee1b05a9e6ba", "typeString": "literal_string \"ERC721: balance query for the zero address\"" } ], "id": 11365, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "4409:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11373, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4409:74:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11374, "nodeType": "ExpressionStatement", "src": "4409:74:86" }, { "expression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11375, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "4501:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 11377, "indexExpression": { "argumentTypes": null, "id": 11376, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11359, "src": "4515:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "4501:20:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 11378, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": 15011, "src": "4501:27:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintSet_$14937_storage_ptr_$returns$_t_uint256_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer) view returns (uint256)" } }, "id": 11379, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4501:29:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "functionReturnParameters": 11364, "id": 11380, "nodeType": "Return", "src": "4494:36:86" } ] }, "documentation": { "id": 11357, "nodeType": "StructuredDocumentation", "src": "4128:193:86", "text": "@dev Gets the balance of the specified address.\n@param owner address to query the balance of\n@return uint256 representing the amount owned by the passed address" }, "functionSelector": "70a08231", "id": 11382, "implemented": true, "kind": "function", "modifiers": [], "name": "balanceOf", "nodeType": "FunctionDefinition", "overrides": { "id": 11361, "nodeType": "OverrideSpecifier", "overrides": [], "src": "4372:8:86" }, "parameters": { "id": 11360, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11359, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11382, "src": "4345:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11358, "name": "address", "nodeType": "ElementaryTypeName", "src": "4345:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "src": "4344:15:86" }, "returnParameters": { "id": 11364, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11363, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11382, "src": "4390:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11362, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "4390:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "4389:9:86" }, "scope": 12203, "src": "4326:211:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12422 ], "body": { "id": 11397, "nodeType": "Block", "src": "4829:94:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11393, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11385, "src": "4863:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "hexValue": "4552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656e", "id": 11394, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "4872:43:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_7481f3df2a424c0755a1ad2356614e9a5a358d461ea2eae1f89cb21cbad00397", "typeString": "literal_string \"ERC721: owner query for nonexistent token\"" }, "value": "ERC721: owner query for nonexistent token" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_stringliteral_7481f3df2a424c0755a1ad2356614e9a5a358d461ea2eae1f89cb21cbad00397", "typeString": "literal_string \"ERC721: owner query for nonexistent token\"" } ], "expression": { "argumentTypes": null, "id": 11391, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "4846:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11392, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "get", "nodeType": "MemberAccess", "referencedDeclaration": 14636, "src": "4846:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$_t_string_memory_ptr_$returns$_t_address_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256,string memory) view returns (address)" } }, "id": 11395, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "4846:70:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "functionReturnParameters": 11390, "id": 11396, "nodeType": "Return", "src": "4839:77:86" } ] }, "documentation": { "id": 11383, "nodeType": "StructuredDocumentation", "src": "4543:208:86", "text": "@dev Gets the owner of the specified token ID.\n@param tokenId uint256 ID of the token to query the owner of\n@return address currently marked as the owner of the given token ID" }, "functionSelector": "6352211e", "id": 11398, "implemented": true, "kind": "function", "modifiers": [], "name": "ownerOf", "nodeType": "FunctionDefinition", "overrides": { "id": 11387, "nodeType": "OverrideSpecifier", "overrides": [], "src": "4802:8:86" }, "parameters": { "id": 11386, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11385, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11398, "src": "4773:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11384, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "4773:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "4772:17:86" }, "returnParameters": { "id": 11390, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11389, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11398, "src": "4820:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11388, "name": "address", "nodeType": "ElementaryTypeName", "src": "4820:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "src": "4819:9:86" }, "scope": 12203, "src": "4756:167:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12523 ], "body": { "id": 11407, "nodeType": "Block", "src": "5089:29:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11405, "name": "_name", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11288, "src": "5106:5:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "functionReturnParameters": 11404, "id": 11406, "nodeType": "Return", "src": "5099:12:86" } ] }, "documentation": { "id": 11399, "nodeType": "StructuredDocumentation", "src": "4929:94:86", "text": "@dev Gets the token name.\n@return string representing the token name" }, "functionSelector": "06fdde03", "id": 11408, "implemented": true, "kind": "function", "modifiers": [], "name": "name", "nodeType": "FunctionDefinition", "overrides": { "id": 11401, "nodeType": "OverrideSpecifier", "overrides": [], "src": "5056:8:86" }, "parameters": { "id": 11400, "nodeType": "ParameterList", "parameters": [], "src": "5041:2:86" }, "returnParameters": { "id": 11404, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11403, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11408, "src": "5074:13:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11402, "name": "string", "nodeType": "ElementaryTypeName", "src": "5074:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "5073:15:86" }, "scope": 12203, "src": "5028:90:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12528 ], "body": { "id": 11417, "nodeType": "Block", "src": "5290:31:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11415, "name": "_symbol", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11290, "src": "5307:7:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "functionReturnParameters": 11414, "id": 11416, "nodeType": "Return", "src": "5300:14:86" } ] }, "documentation": { "id": 11409, "nodeType": "StructuredDocumentation", "src": "5124:98:86", "text": "@dev Gets the token symbol.\n@return string representing the token symbol" }, "functionSelector": "95d89b41", "id": 11418, "implemented": true, "kind": "function", "modifiers": [], "name": "symbol", "nodeType": "FunctionDefinition", "overrides": { "id": 11411, "nodeType": "OverrideSpecifier", "overrides": [], "src": "5257:8:86" }, "parameters": { "id": 11410, "nodeType": "ParameterList", "parameters": [], "src": "5242:2:86" }, "returnParameters": { "id": 11414, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11413, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11418, "src": "5275:13:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11412, "name": "string", "nodeType": "ElementaryTypeName", "src": "5275:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "5274:15:86" }, "scope": 12203, "src": "5227:94:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12535 ], "body": { "id": 11480, "nodeType": "Block", "src": "6244:660:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11429, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11421, "src": "6270:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11428, "name": "_exists", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11774, "src": "6262:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", "typeString": "function (uint256) view returns (bool)" } }, "id": 11430, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6262:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732314d657461646174613a2055524920717565727920666f72206e6f6e6578697374656e7420746f6b656e", "id": 11431, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "6280:49:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_a2d45c0fba603d40d82d590051761ca952d1ab9d78cca6d0d464d7b6e961a9cb", "typeString": "literal_string \"ERC721Metadata: URI query for nonexistent token\"" }, "value": "ERC721Metadata: URI query for nonexistent token" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_a2d45c0fba603d40d82d590051761ca952d1ab9d78cca6d0d464d7b6e961a9cb", "typeString": "literal_string \"ERC721Metadata: URI query for nonexistent token\"" } ], "id": 11427, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "6254:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11432, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6254:76:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11433, "nodeType": "ExpressionStatement", "src": "6254:76:86" }, { "assignments": [ 11435 ], "declarations": [ { "constant": false, "id": 11435, "mutability": "mutable", "name": "_tokenURI", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11480, "src": "6341:23:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11434, "name": "string", "nodeType": "ElementaryTypeName", "src": "6341:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "id": 11439, "initialValue": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11436, "name": "_tokenURIs", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11294, "src": "6367:10:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string storage ref)" } }, "id": 11438, "indexExpression": { "argumentTypes": null, "id": 11437, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11421, "src": "6378:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "6367:19:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "nodeType": "VariableDeclarationStatement", "src": "6341:45:86" }, { "condition": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "id": 11446, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11442, "name": "_baseURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11296, "src": "6465:8:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } ], "id": 11441, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "6459:5:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_bytes_storage_ptr_$", "typeString": "type(bytes storage pointer)" }, "typeName": { "id": 11440, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "6459:5:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11443, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6459:15:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes storage pointer" } }, "id": 11444, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "6459:22:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "hexValue": "30", "id": 11445, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "6485:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" }, "src": "6459:27:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": null, "id": 11450, "nodeType": "IfStatement", "src": "6455:74:86", "trueBody": { "id": 11449, "nodeType": "Block", "src": "6488:41:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11447, "name": "_tokenURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11435, "src": "6509:9:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "functionReturnParameters": 11426, "id": 11448, "nodeType": "Return", "src": "6502:16:86" } ] } }, { "condition": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "id": 11457, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11453, "name": "_tokenURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11435, "src": "6637:9:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } ], "id": 11452, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "6631:5:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_bytes_storage_ptr_$", "typeString": "type(bytes storage pointer)" }, "typeName": { "id": 11451, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "6631:5:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11454, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6631:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } }, "id": 11455, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "6631:23:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "BinaryOperation", "operator": ">", "rightExpression": { "argumentTypes": null, "hexValue": "30", "id": 11456, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "6657:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" }, "src": "6631:27:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": null, "id": 11468, "nodeType": "IfStatement", "src": "6627:110:86", "trueBody": { "id": 11467, "nodeType": "Block", "src": "6660:77:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11462, "name": "_baseURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11296, "src": "6705:8:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, { "argumentTypes": null, "id": 11463, "name": "_tokenURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11435, "src": "6715:9:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" }, { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } ], "expression": { "argumentTypes": null, "id": 11460, "name": "abi", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": -1, "src": "6688:3:86", "typeDescriptions": { "typeIdentifier": "t_magic_abi", "typeString": "abi" } }, "id": 11461, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "memberName": "encodePacked", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "6688:16:86", "typeDescriptions": { "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$", "typeString": "function () pure returns (bytes memory)" } }, "id": 11464, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6688:37:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "id": 11459, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "6681:6:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_string_storage_ptr_$", "typeString": "type(string storage pointer)" }, "typeName": { "id": 11458, "name": "string", "nodeType": "ElementaryTypeName", "src": "6681:6:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11465, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6681:45:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "functionReturnParameters": 11426, "id": 11466, "nodeType": "Return", "src": "6674:52:86" } ] } }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11473, "name": "_baseURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11296, "src": "6867:8:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "expression": { "argumentTypes": null, "id": 11474, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11421, "src": "6877:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "id": 11475, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "toString", "nodeType": "MemberAccess", "referencedDeclaration": 15442, "src": "6877:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_pure$_t_uint256_$returns$_t_string_memory_ptr_$bound_to$_t_uint256_$", "typeString": "function (uint256) pure returns (string memory)" } }, "id": 11476, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6877:18:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" }, { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } ], "expression": { "argumentTypes": null, "id": 11471, "name": "abi", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": -1, "src": "6850:3:86", "typeDescriptions": { "typeIdentifier": "t_magic_abi", "typeString": "abi" } }, "id": 11472, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "memberName": "encodePacked", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "6850:16:86", "typeDescriptions": { "typeIdentifier": "t_function_abiencodepacked_pure$__$returns$_t_bytes_memory_ptr_$", "typeString": "function () pure returns (bytes memory)" } }, "id": 11477, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6850:46:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "id": 11470, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "6843:6:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_string_storage_ptr_$", "typeString": "type(string storage pointer)" }, "typeName": { "id": 11469, "name": "string", "nodeType": "ElementaryTypeName", "src": "6843:6:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11478, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "6843:54:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "functionReturnParameters": 11426, "id": 11479, "nodeType": "Return", "src": "6836:61:86" } ] }, "documentation": { "id": 11419, "nodeType": "StructuredDocumentation", "src": "5327:832:86", "text": "@dev Returns the URI for a given token ID. May return an empty string.\n * If a base URI is set (via {_setBaseURI}), it is added as a prefix to the\ntoken's own URI (via {_setTokenURI}).\n * If there is a base URI but no token URI, the token's ID will be used as\nits URI when appending it to the base URI. This pattern for autogenerated\ntoken URIs can lead to large gas savings.\n * .Examples\n|===\n|`_setBaseURI()` |`_setTokenURI()` |`tokenURI()`\n| \"\"\n| \"\"\n| \"\"\n| \"\"\n| \"token.uri/123\"\n| \"token.uri/123\"\n| \"token.uri/\"\n| \"123\"\n| \"token.uri/123\"\n| \"token.uri/\"\n| \"\"\n| \"token.uri/\"\n|===\n * Requirements:\n * - `tokenId` must exist." }, "functionSelector": "c87b56dd", "id": 11481, "implemented": true, "kind": "function", "modifiers": [], "name": "tokenURI", "nodeType": "FunctionDefinition", "overrides": { "id": 11423, "nodeType": "OverrideSpecifier", "overrides": [], "src": "6211:8:86" }, "parameters": { "id": 11422, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11421, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11481, "src": "6182:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11420, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "6182:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "6181:17:86" }, "returnParameters": { "id": 11426, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11425, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11481, "src": "6229:13:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11424, "name": "string", "nodeType": "ElementaryTypeName", "src": "6229:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "6228:15:86" }, "scope": 12203, "src": "6164:740:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "body": { "id": 11489, "nodeType": "Block", "src": "7191:32:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11487, "name": "_baseURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11296, "src": "7208:8:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "functionReturnParameters": 11486, "id": 11488, "nodeType": "Return", "src": "7201:15:86" } ] }, "documentation": { "id": 11482, "nodeType": "StructuredDocumentation", "src": "6910:221:86", "text": "@dev Returns the base URI set via {_setBaseURI}. This will be\nautomatically added as a prefix in {tokenURI} to each token's URI, or\nto the token ID if no specific URI is set for that token ID." }, "functionSelector": "6c0360eb", "id": 11490, "implemented": true, "kind": "function", "modifiers": [], "name": "baseURI", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11483, "nodeType": "ParameterList", "parameters": [], "src": "7152:2:86" }, "returnParameters": { "id": 11486, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11485, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11490, "src": "7176:13:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 11484, "name": "string", "nodeType": "ElementaryTypeName", "src": "7176:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "7175:15:86" }, "scope": 12203, "src": "7136:87:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12504 ], "body": { "id": 11508, "nodeType": "Block", "src": "7695:54:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11505, "name": "index", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11495, "src": "7736:5:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11501, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "7712:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 11503, "indexExpression": { "argumentTypes": null, "id": 11502, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11493, "src": "7726:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "7712:20:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 11504, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "at", "nodeType": "MemberAccess", "referencedDeclaration": 15031, "src": "7712:23:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintSet_$14937_storage_ptr_$_t_uint256_$returns$_t_uint256_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer,uint256) view returns (uint256)" } }, "id": 11506, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "7712:30:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "functionReturnParameters": 11500, "id": 11507, "nodeType": "Return", "src": "7705:37:86" } ] }, "documentation": { "id": 11491, "nodeType": "StructuredDocumentation", "src": "7229:363:86", "text": "@dev Gets the token ID at a given index of the tokens list of the requested owner.\n@param owner address owning the tokens list to be accessed\n@param index uint256 representing the index to be accessed of the requested tokens list\n@return uint256 token ID at the given index of the tokens list owned by the requested address" }, "functionSelector": "2f745c59", "id": 11509, "implemented": true, "kind": "function", "modifiers": [], "name": "tokenOfOwnerByIndex", "nodeType": "FunctionDefinition", "overrides": { "id": 11497, "nodeType": "OverrideSpecifier", "overrides": [], "src": "7668:8:86" }, "parameters": { "id": 11496, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11493, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11509, "src": "7626:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11492, "name": "address", "nodeType": "ElementaryTypeName", "src": "7626:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11495, "mutability": "mutable", "name": "index", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11509, "src": "7641:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11494, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "7641:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "7625:30:86" }, "returnParameters": { "id": 11500, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11499, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11509, "src": "7686:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11498, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "7686:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "7685:9:86" }, "scope": 12203, "src": "7597:152:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12495 ], "body": { "id": 11520, "nodeType": "Block", "src": "7964:138:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "expression": { "argumentTypes": null, "id": 11516, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "8074:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11517, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": 14545, "src": "8074:19:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintToAddressMap_$14462_storage_ptr_$returns$_t_uint256_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer) view returns (uint256)" } }, "id": 11518, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "8074:21:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "functionReturnParameters": 11515, "id": 11519, "nodeType": "Return", "src": "8067:28:86" } ] }, "documentation": { "id": 11510, "nodeType": "StructuredDocumentation", "src": "7755:142:86", "text": "@dev Gets the total amount of tokens stored by the contract.\n@return uint256 representing the total amount of tokens" }, "functionSelector": "18160ddd", "id": 11521, "implemented": true, "kind": "function", "modifiers": [], "name": "totalSupply", "nodeType": "FunctionDefinition", "overrides": { "id": 11512, "nodeType": "OverrideSpecifier", "overrides": [], "src": "7937:8:86" }, "parameters": { "id": 11511, "nodeType": "ParameterList", "parameters": [], "src": "7922:2:86" }, "returnParameters": { "id": 11515, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11514, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11521, "src": "7955:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11513, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "7955:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "7954:9:86" }, "scope": 12203, "src": "7902:200:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12511 ], "body": { "id": 11539, "nodeType": "Block", "src": "8516:85:86", "statements": [ { "assignments": [ 11531, null ], "declarations": [ { "constant": false, "id": 11531, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11539, "src": "8527:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11530, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "8527:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, null ], "id": 11536, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11534, "name": "index", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11524, "src": "8564:5:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "id": 11532, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "8548:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11533, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "at", "nodeType": "MemberAccess", "referencedDeclaration": 14581, "src": "8548:15:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$returns$_t_uint256_$_t_address_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256) view returns (uint256,address)" } }, "id": 11535, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "8548:22:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$_t_uint256_$_t_address_$", "typeString": "tuple(uint256,address)" } }, "nodeType": "VariableDeclarationStatement", "src": "8526:44:86" }, { "expression": { "argumentTypes": null, "id": 11537, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11531, "src": "8587:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "functionReturnParameters": 11529, "id": 11538, "nodeType": "Return", "src": "8580:14:86" } ] }, "documentation": { "id": 11522, "nodeType": "StructuredDocumentation", "src": "8108:327:86", "text": "@dev Gets the token ID at a given index of all the tokens in this contract\nReverts if the index is greater or equal to the total number of tokens.\n@param index uint256 representing the index to be accessed of the tokens list\n@return uint256 token ID at the given index of the tokens list" }, "functionSelector": "4f6ccce7", "id": 11540, "implemented": true, "kind": "function", "modifiers": [], "name": "tokenByIndex", "nodeType": "FunctionDefinition", "overrides": { "id": 11526, "nodeType": "OverrideSpecifier", "overrides": [], "src": "8489:8:86" }, "parameters": { "id": 11525, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11524, "mutability": "mutable", "name": "index", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11540, "src": "8462:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11523, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "8462:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "8461:15:86" }, "returnParameters": { "id": 11529, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11528, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11540, "src": "8507:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11527, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "8507:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "8506:9:86" }, "scope": 12203, "src": "8440:161:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12449 ], "body": { "id": 11581, "nodeType": "Block", "src": "9092:311:86", "statements": [ { "assignments": [ 11550 ], "declarations": [ { "constant": false, "id": 11550, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11581, "src": "9102:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11549, "name": "address", "nodeType": "ElementaryTypeName", "src": "9102:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "id": 11554, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11552, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11545, "src": "9126:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11551, "name": "ownerOf", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11398, "src": "9118:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 11553, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9118:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "VariableDeclarationStatement", "src": "9102:32:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11558, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 11556, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11543, "src": "9152:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "id": 11557, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11550, "src": "9158:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "9152:11:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a20617070726f76616c20746f2063757272656e74206f776e6572", "id": 11559, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "9165:35:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_b51b4875eede07862961e8f9365c6749f5fe55c6ee5d7a9e42b6912ad0b15942", "typeString": "literal_string \"ERC721: approval to current owner\"" }, "value": "ERC721: approval to current owner" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_b51b4875eede07862961e8f9365c6749f5fe55c6ee5d7a9e42b6912ad0b15942", "typeString": "literal_string \"ERC721: approval to current owner\"" } ], "id": 11555, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "9144:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11560, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9144:57:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11561, "nodeType": "ExpressionStatement", "src": "9144:57:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_bool", "typeString": "bool" }, "id": 11572, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11566, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11563, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "9220:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11564, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9220:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "id": 11565, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11550, "src": "9236:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "9220:21:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "nodeType": "BinaryOperation", "operator": "||", "rightExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11568, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11550, "src": "9262:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11569, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "9269:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11570, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9269:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address_payable", "typeString": "address payable" } ], "id": 11567, "name": "isApprovedForAll", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11655, "src": "9245:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_address_$_t_address_$returns$_t_bool_$", "typeString": "function (address,address) view returns (bool)" } }, "id": 11571, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9245:37:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "src": "9220:62:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a20617070726f76652063616c6c6572206973206e6f74206f776e6572206e6f7220617070726f76656420666f7220616c6c", "id": 11573, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "9296:58:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_6d83cef3e0cb19b8320a9c5feb26b56bbb08f152a8e61b12eca3302d8d68b23d", "typeString": "literal_string \"ERC721: approve caller is not owner nor approved for all\"" }, "value": "ERC721: approve caller is not owner nor approved for all" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_6d83cef3e0cb19b8320a9c5feb26b56bbb08f152a8e61b12eca3302d8d68b23d", "typeString": "literal_string \"ERC721: approve caller is not owner nor approved for all\"" } ], "id": 11562, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "9212:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11574, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9212:152:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11575, "nodeType": "ExpressionStatement", "src": "9212:152:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11577, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11543, "src": "9384:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11578, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11545, "src": "9388:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11576, "name": "_approve", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12187, "src": "9375:8:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,uint256)" } }, "id": 11579, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9375:21:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11580, "nodeType": "ExpressionStatement", "src": "9375:21:86" } ] }, "documentation": { "id": 11541, "nodeType": "StructuredDocumentation", "src": "8607:410:86", "text": "@dev Approves another address to transfer the given token ID\nThe zero address indicates there is no approved address.\nThere can only be one approved address per token at a given time.\nCan only be called by the token owner or an approved operator.\n@param to address to be approved for the given token ID\n@param tokenId uint256 ID of the token to be approved" }, "functionSelector": "095ea7b3", "id": 11582, "implemented": true, "kind": "function", "modifiers": [], "name": "approve", "nodeType": "FunctionDefinition", "overrides": { "id": 11547, "nodeType": "OverrideSpecifier", "overrides": [], "src": "9083:8:86" }, "parameters": { "id": 11546, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11543, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11582, "src": "9039:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11542, "name": "address", "nodeType": "ElementaryTypeName", "src": "9039:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11545, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11582, "src": "9051:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11544, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "9051:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "9038:29:86" }, "returnParameters": { "id": 11548, "nodeType": "ParameterList", "parameters": [], "src": "9092:0:86" }, "scope": 12203, "src": "9022:381:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "public" }, { "baseFunctions": [ 12456 ], "body": { "id": 11602, "nodeType": "Block", "src": "9765:132:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11593, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11585, "src": "9791:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11592, "name": "_exists", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11774, "src": "9783:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", "typeString": "function (uint256) view returns (bool)" } }, "id": 11594, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9783:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a20617070726f76656420717565727920666f72206e6f6e6578697374656e7420746f6b656e", "id": 11595, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "9801:46:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_9291e0f44949204f2e9b40e6be090924979d6047b2365868f4e9f027722eb89d", "typeString": "literal_string \"ERC721: approved query for nonexistent token\"" }, "value": "ERC721: approved query for nonexistent token" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_9291e0f44949204f2e9b40e6be090924979d6047b2365868f4e9f027722eb89d", "typeString": "literal_string \"ERC721: approved query for nonexistent token\"" } ], "id": 11591, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "9775:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11596, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "9775:73:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11597, "nodeType": "ExpressionStatement", "src": "9775:73:86" }, { "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11598, "name": "_tokenApprovals", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11280, "src": "9866:15:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_address_$", "typeString": "mapping(uint256 => address)" } }, "id": 11600, "indexExpression": { "argumentTypes": null, "id": 11599, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11585, "src": "9882:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "9866:24:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "functionReturnParameters": 11590, "id": 11601, "nodeType": "Return", "src": "9859:31:86" } ] }, "documentation": { "id": 11583, "nodeType": "StructuredDocumentation", "src": "9409:274:86", "text": "@dev Gets the approved address for a token ID, or zero if no address set\nReverts if the token ID does not exist.\n@param tokenId uint256 ID of the token to query the approval of\n@return address currently approved for the given token ID" }, "functionSelector": "081812fc", "id": 11603, "implemented": true, "kind": "function", "modifiers": [], "name": "getApproved", "nodeType": "FunctionDefinition", "overrides": { "id": 11587, "nodeType": "OverrideSpecifier", "overrides": [], "src": "9738:8:86" }, "parameters": { "id": 11586, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11585, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11603, "src": "9709:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11584, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "9709:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "9708:17:86" }, "returnParameters": { "id": 11590, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11589, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11603, "src": "9756:7:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11588, "name": "address", "nodeType": "ElementaryTypeName", "src": "9756:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "src": "9755:9:86" }, "scope": 12203, "src": "9688:209:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12463 ], "body": { "id": 11636, "nodeType": "Block", "src": "10280:206:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11616, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 11613, "name": "operator", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11606, "src": "10298:8:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11614, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "10310:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11615, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "10310:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "src": "10298:24:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a20617070726f766520746f2063616c6c6572", "id": 11617, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "10324:27:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_45fe4329685be5ecd250fd0e6a25aea0ea4d0e30fb6a73c118b95749e6d70d05", "typeString": "literal_string \"ERC721: approve to caller\"" }, "value": "ERC721: approve to caller" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_45fe4329685be5ecd250fd0e6a25aea0ea4d0e30fb6a73c118b95749e6d70d05", "typeString": "literal_string \"ERC721: approve to caller\"" } ], "id": 11612, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "10290:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11618, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "10290:62:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11619, "nodeType": "ExpressionStatement", "src": "10290:62:86" }, { "expression": { "argumentTypes": null, "id": 11627, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11620, "name": "_operatorApprovals", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11286, "src": "10363:18:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_address_$_t_bool_$_$", "typeString": "mapping(address => mapping(address => bool))" } }, "id": 11624, "indexExpression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11621, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "10382:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11622, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "10382:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "10363:32:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", "typeString": "mapping(address => bool)" } }, "id": 11625, "indexExpression": { "argumentTypes": null, "id": 11623, "name": "operator", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11606, "src": "10396:8:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": true, "nodeType": "IndexAccess", "src": "10363:42:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 11626, "name": "approved", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11608, "src": "10408:8:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "src": "10363:53:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 11628, "nodeType": "ExpressionStatement", "src": "10363:53:86" }, { "eventCall": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11630, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "10446:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11631, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "10446:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11632, "name": "operator", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11606, "src": "10460:8:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11633, "name": "approved", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11608, "src": "10470:8:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_bool", "typeString": "bool" } ], "id": 11629, "name": "ApprovalForAll", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12406, "src": "10431:14:86", "typeDescriptions": { "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_address_$_t_bool_$returns$__$", "typeString": "function (address,address,bool)" } }, "id": 11634, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "10431:48:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11635, "nodeType": "EmitStatement", "src": "10426:53:86" } ] }, "documentation": { "id": 11604, "nodeType": "StructuredDocumentation", "src": "9903:288:86", "text": "@dev Sets or unsets the approval of a given operator\nAn operator is allowed to transfer all tokens of the sender on their behalf.\n@param operator operator address to set the approval\n@param approved representing the status of the approval to be set" }, "functionSelector": "a22cb465", "id": 11637, "implemented": true, "kind": "function", "modifiers": [], "name": "setApprovalForAll", "nodeType": "FunctionDefinition", "overrides": { "id": 11610, "nodeType": "OverrideSpecifier", "overrides": [], "src": "10271:8:86" }, "parameters": { "id": 11609, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11606, "mutability": "mutable", "name": "operator", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11637, "src": "10223:16:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11605, "name": "address", "nodeType": "ElementaryTypeName", "src": "10223:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11608, "mutability": "mutable", "name": "approved", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11637, "src": "10241:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 11607, "name": "bool", "nodeType": "ElementaryTypeName", "src": "10241:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" } ], "src": "10222:33:86" }, "returnParameters": { "id": 11611, "nodeType": "ParameterList", "parameters": [], "src": "10280:0:86" }, "scope": 12203, "src": "10196:290:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "public" }, { "baseFunctions": [ 12472 ], "body": { "id": 11654, "nodeType": "Block", "src": "10903:59:86", "statements": [ { "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11648, "name": "_operatorApprovals", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11286, "src": "10920:18:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_mapping$_t_address_$_t_bool_$_$", "typeString": "mapping(address => mapping(address => bool))" } }, "id": 11650, "indexExpression": { "argumentTypes": null, "id": 11649, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11640, "src": "10939:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "10920:25:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_bool_$", "typeString": "mapping(address => bool)" } }, "id": 11652, "indexExpression": { "argumentTypes": null, "id": 11651, "name": "operator", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11642, "src": "10946:8:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "10920:35:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "functionReturnParameters": 11647, "id": 11653, "nodeType": "Return", "src": "10913:42:86" } ] }, "documentation": { "id": 11638, "nodeType": "StructuredDocumentation", "src": "10492:311:86", "text": "@dev Tells whether an operator is approved by a given owner.\n@param owner owner address which you want to query the approval of\n@param operator operator address which you want to query the approval of\n@return bool whether the given operator is approved by the given owner" }, "functionSelector": "e985e9c5", "id": 11655, "implemented": true, "kind": "function", "modifiers": [], "name": "isApprovedForAll", "nodeType": "FunctionDefinition", "overrides": { "id": 11644, "nodeType": "OverrideSpecifier", "overrides": [], "src": "10879:8:86" }, "parameters": { "id": 11643, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11640, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11655, "src": "10834:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11639, "name": "address", "nodeType": "ElementaryTypeName", "src": "10834:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11642, "mutability": "mutable", "name": "operator", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11655, "src": "10849:16:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11641, "name": "address", "nodeType": "ElementaryTypeName", "src": "10849:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "src": "10833:33:86" }, "returnParameters": { "id": 11647, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11646, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11655, "src": "10897:4:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 11645, "name": "bool", "nodeType": "ElementaryTypeName", "src": "10897:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" } ], "src": "10896:6:86" }, "scope": 12203, "src": "10808:154:86", "stateMutability": "view", "virtual": false, "visibility": "public" }, { "baseFunctions": [ 12442 ], "body": { "id": 11681, "nodeType": "Block", "src": "11488:211:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11668, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "11577:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11669, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "11577:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11670, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11662, "src": "11591:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11667, "name": "_isApprovedOrOwner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11814, "src": "11558:18:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_address_$_t_uint256_$returns$_t_bool_$", "typeString": "function (address,uint256) view returns (bool)" } }, "id": 11671, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "11558:41:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e736665722063616c6c6572206973206e6f74206f776e6572206e6f7220617070726f766564", "id": 11672, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "11601:51:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_c8682f3ad98807db59a6ec6bb812b72fed0a66e3150fa8239699ee83885247f2", "typeString": "literal_string \"ERC721: transfer caller is not owner nor approved\"" }, "value": "ERC721: transfer caller is not owner nor approved" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_c8682f3ad98807db59a6ec6bb812b72fed0a66e3150fa8239699ee83885247f2", "typeString": "literal_string \"ERC721: transfer caller is not owner nor approved\"" } ], "id": 11666, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "11550:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11673, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "11550:103:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11674, "nodeType": "ExpressionStatement", "src": "11550:103:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11676, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11658, "src": "11674:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11677, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11660, "src": "11680:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11678, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11662, "src": "11684:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11675, "name": "_transfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12056, "src": "11664:9:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11679, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "11664:28:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11680, "nodeType": "ExpressionStatement", "src": "11664:28:86" } ] }, "documentation": { "id": 11656, "nodeType": "StructuredDocumentation", "src": "10968:426:86", "text": "@dev Transfers the ownership of a given token ID to another address.\nUsage of this method is discouraged, use {safeTransferFrom} whenever possible.\nRequires the msg.sender to be the owner, approved, or operator.\n@param from current owner of the token\n@param to address to receive the ownership of the given token ID\n@param tokenId uint256 ID of the token to be transferred" }, "functionSelector": "23b872dd", "id": 11682, "implemented": true, "kind": "function", "modifiers": [], "name": "transferFrom", "nodeType": "FunctionDefinition", "overrides": { "id": 11664, "nodeType": "OverrideSpecifier", "overrides": [], "src": "11479:8:86" }, "parameters": { "id": 11663, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11658, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11682, "src": "11421:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11657, "name": "address", "nodeType": "ElementaryTypeName", "src": "11421:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11660, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11682, "src": "11435:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11659, "name": "address", "nodeType": "ElementaryTypeName", "src": "11435:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11662, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11682, "src": "11447:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11661, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "11447:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "11420:43:86" }, "returnParameters": { "id": 11665, "nodeType": "ParameterList", "parameters": [], "src": "11488:0:86" }, "scope": 12203, "src": "11399:300:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "public" }, { "baseFunctions": [ 12432 ], "body": { "id": 11700, "nodeType": "Block", "src": "12441:56:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11694, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11685, "src": "12468:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11695, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11687, "src": "12474:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11696, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11689, "src": "12478:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "hexValue": "", "id": 11697, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "12487:2:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "typeString": "literal_string \"\"" }, "value": "" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "typeString": "literal_string \"\"" } ], "id": 11693, "name": "safeTransferFrom", "nodeType": "Identifier", "overloadedDeclarations": [ 11701, 11731 ], "referencedDeclaration": 11731, "src": "12451:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$__$", "typeString": "function (address,address,uint256,bytes memory)" } }, "id": 11698, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "12451:39:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11699, "nodeType": "ExpressionStatement", "src": "12451:39:86" } ] }, "documentation": { "id": 11683, "nodeType": "StructuredDocumentation", "src": "11705:638:86", "text": "@dev Safely transfers the ownership of a given token ID to another address\nIf the target address is a contract, it must implement {IERC721Receiver-onERC721Received},\nwhich is called upon a safe transfer, and return the magic value\n`bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\nthe transfer is reverted.\nRequires the msg.sender to be the owner, approved, or operator\n@param from current owner of the token\n@param to address to receive the ownership of the given token ID\n@param tokenId uint256 ID of the token to be transferred" }, "functionSelector": "42842e0e", "id": 11701, "implemented": true, "kind": "function", "modifiers": [], "name": "safeTransferFrom", "nodeType": "FunctionDefinition", "overrides": { "id": 11691, "nodeType": "OverrideSpecifier", "overrides": [], "src": "12432:8:86" }, "parameters": { "id": 11690, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11685, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11701, "src": "12374:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11684, "name": "address", "nodeType": "ElementaryTypeName", "src": "12374:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11687, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11701, "src": "12388:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11686, "name": "address", "nodeType": "ElementaryTypeName", "src": "12388:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11689, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11701, "src": "12400:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11688, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "12400:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "12373:43:86" }, "returnParameters": { "id": 11692, "nodeType": "ParameterList", "parameters": [], "src": "12441:0:86" }, "scope": 12203, "src": "12348:149:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "public" }, { "baseFunctions": [ 12483 ], "body": { "id": 11730, "nodeType": "Block", "src": "13333:169:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 11716, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "13370:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 11717, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "13370:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11718, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11708, "src": "13384:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11715, "name": "_isApprovedOrOwner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11814, "src": "13351:18:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_address_$_t_uint256_$returns$_t_bool_$", "typeString": "function (address,uint256) view returns (bool)" } }, "id": 11719, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "13351:41:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e736665722063616c6c6572206973206e6f74206f776e6572206e6f7220617070726f766564", "id": 11720, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "13394:51:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_c8682f3ad98807db59a6ec6bb812b72fed0a66e3150fa8239699ee83885247f2", "typeString": "literal_string \"ERC721: transfer caller is not owner nor approved\"" }, "value": "ERC721: transfer caller is not owner nor approved" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_c8682f3ad98807db59a6ec6bb812b72fed0a66e3150fa8239699ee83885247f2", "typeString": "literal_string \"ERC721: transfer caller is not owner nor approved\"" } ], "id": 11714, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "13343:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11721, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "13343:103:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11722, "nodeType": "ExpressionStatement", "src": "13343:103:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11724, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11704, "src": "13470:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11725, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11706, "src": "13476:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11726, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11708, "src": "13480:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 11727, "name": "_data", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11710, "src": "13489:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "id": 11723, "name": "_safeTransfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11760, "src": "13456:13:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$__$", "typeString": "function (address,address,uint256,bytes memory)" } }, "id": 11728, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "13456:39:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11729, "nodeType": "ExpressionStatement", "src": "13456:39:86" } ] }, "documentation": { "id": 11702, "nodeType": "StructuredDocumentation", "src": "12503:712:86", "text": "@dev Safely transfers the ownership of a given token ID to another address\nIf the target address is a contract, it must implement {IERC721Receiver-onERC721Received},\nwhich is called upon a safe transfer, and return the magic value\n`bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\nthe transfer is reverted.\nRequires the _msgSender() to be the owner, approved, or operator\n@param from current owner of the token\n@param to address to receive the ownership of the given token ID\n@param tokenId uint256 ID of the token to be transferred\n@param _data bytes data to send along with a safe transfer check" }, "functionSelector": "b88d4fde", "id": 11731, "implemented": true, "kind": "function", "modifiers": [], "name": "safeTransferFrom", "nodeType": "FunctionDefinition", "overrides": { "id": 11712, "nodeType": "OverrideSpecifier", "overrides": [], "src": "13324:8:86" }, "parameters": { "id": 11711, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11704, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11731, "src": "13246:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11703, "name": "address", "nodeType": "ElementaryTypeName", "src": "13246:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11706, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11731, "src": "13260:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11705, "name": "address", "nodeType": "ElementaryTypeName", "src": "13260:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11708, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11731, "src": "13272:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11707, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "13272:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11710, "mutability": "mutable", "name": "_data", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11731, "src": "13289:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes" }, "typeName": { "id": 11709, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "13289:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes" } }, "value": null, "visibility": "internal" } ], "src": "13245:63:86" }, "returnParameters": { "id": 11713, "nodeType": "ParameterList", "parameters": [], "src": "13333:0:86" }, "scope": 12203, "src": "13220:282:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "public" }, { "body": { "id": 11759, "nodeType": "Block", "src": "14310:166:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11744, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11734, "src": "14330:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11745, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11736, "src": "14336:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11746, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11738, "src": "14340:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11743, "name": "_transfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12056, "src": "14320:9:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11747, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "14320:28:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11748, "nodeType": "ExpressionStatement", "src": "14320:28:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11751, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11734, "src": "14389:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11752, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11736, "src": "14395:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11753, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11738, "src": "14399:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 11754, "name": "_data", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11740, "src": "14408:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "id": 11750, "name": "_checkOnERC721Received", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12165, "src": "14366:22:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$_t_bool_$", "typeString": "function (address,address,uint256,bytes memory) returns (bool)" } }, "id": 11755, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "14366:48:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e746572", "id": 11756, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "14416:52:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" }, "value": "ERC721: transfer to non ERC721Receiver implementer" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" } ], "id": 11749, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "14358:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11757, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "14358:111:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11758, "nodeType": "ExpressionStatement", "src": "14358:111:86" } ] }, "documentation": { "id": 11732, "nodeType": "StructuredDocumentation", "src": "13508:694:86", "text": "@dev Safely transfers the ownership of a given token ID to another address\nIf the target address is a contract, it must implement `onERC721Received`,\nwhich is called upon a safe transfer, and return the magic value\n`bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\nthe transfer is reverted.\nRequires the msg.sender to be the owner, approved, or operator\n@param from current owner of the token\n@param to address to receive the ownership of the given token ID\n@param tokenId uint256 ID of the token to be transferred\n@param _data bytes data to send along with a safe transfer check" }, "id": 11760, "implemented": true, "kind": "function", "modifiers": [], "name": "_safeTransfer", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11741, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11734, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11760, "src": "14230:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11733, "name": "address", "nodeType": "ElementaryTypeName", "src": "14230:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11736, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11760, "src": "14244:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11735, "name": "address", "nodeType": "ElementaryTypeName", "src": "14244:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11738, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11760, "src": "14256:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11737, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "14256:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11740, "mutability": "mutable", "name": "_data", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11760, "src": "14273:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes" }, "typeName": { "id": 11739, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "14273:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes" } }, "value": null, "visibility": "internal" } ], "src": "14229:63:86" }, "returnParameters": { "id": 11742, "nodeType": "ParameterList", "parameters": [], "src": "14310:0:86" }, "scope": 12203, "src": "14207:269:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 11773, "nodeType": "Block", "src": "14734:54:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11770, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11763, "src": "14773:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "id": 11768, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "14751:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11769, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "contains", "nodeType": "MemberAccess", "referencedDeclaration": 14531, "src": "14751:21:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256) view returns (bool)" } }, "id": 11771, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "14751:30:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "functionReturnParameters": 11767, "id": 11772, "nodeType": "Return", "src": "14744:37:86" } ] }, "documentation": { "id": 11761, "nodeType": "StructuredDocumentation", "src": "14482:184:86", "text": "@dev Returns whether the specified token exists.\n@param tokenId uint256 ID of the token to query the existence of\n@return bool whether the token exists" }, "id": 11774, "implemented": true, "kind": "function", "modifiers": [], "name": "_exists", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11764, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11763, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11774, "src": "14688:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11762, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "14688:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "14687:17:86" }, "returnParameters": { "id": 11767, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11766, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11774, "src": "14728:4:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 11765, "name": "bool", "nodeType": "ElementaryTypeName", "src": "14728:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" } ], "src": "14727:6:86" }, "scope": 12203, "src": "14671:117:86", "stateMutability": "view", "virtual": false, "visibility": "internal" }, { "body": { "id": 11813, "nodeType": "Block", "src": "15240:238:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11786, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11779, "src": "15266:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11785, "name": "_exists", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11774, "src": "15258:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", "typeString": "function (uint256) view returns (bool)" } }, "id": 11787, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "15258:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578697374656e7420746f6b656e", "id": 11788, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "15276:46:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_5797d1ccb08b83980dd0c07ea40d8f6a64d35fff736a19bdd17522954cb0899c", "typeString": "literal_string \"ERC721: operator query for nonexistent token\"" }, "value": "ERC721: operator query for nonexistent token" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_5797d1ccb08b83980dd0c07ea40d8f6a64d35fff736a19bdd17522954cb0899c", "typeString": "literal_string \"ERC721: operator query for nonexistent token\"" } ], "id": 11784, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "15250:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11789, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "15250:73:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11790, "nodeType": "ExpressionStatement", "src": "15250:73:86" }, { "assignments": [ 11792 ], "declarations": [ { "constant": false, "id": 11792, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11813, "src": "15333:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11791, "name": "address", "nodeType": "ElementaryTypeName", "src": "15333:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "id": 11796, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11794, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11779, "src": "15357:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11793, "name": "ownerOf", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11398, "src": "15349:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 11795, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "15349:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "VariableDeclarationStatement", "src": "15333:32:86" }, { "expression": { "argumentTypes": null, "components": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_bool", "typeString": "bool" }, "id": 11810, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_bool", "typeString": "bool" }, "id": 11805, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11799, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 11797, "name": "spender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11777, "src": "15383:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "id": 11798, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11792, "src": "15394:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "15383:16:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "nodeType": "BinaryOperation", "operator": "||", "rightExpression": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11804, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11801, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11779, "src": "15415:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11800, "name": "getApproved", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11603, "src": "15403:11:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 11802, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "15403:20:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "id": 11803, "name": "spender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11777, "src": "15427:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "15403:31:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "src": "15383:51:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "nodeType": "BinaryOperation", "operator": "||", "rightExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11807, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11792, "src": "15455:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11808, "name": "spender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11777, "src": "15462:7:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" } ], "id": 11806, "name": "isApprovedForAll", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11655, "src": "15438:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_address_$_t_address_$returns$_t_bool_$", "typeString": "function (address,address) view returns (bool)" } }, "id": 11809, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "15438:32:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "src": "15383:87:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } } ], "id": 11811, "isConstant": false, "isInlineArray": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "TupleExpression", "src": "15382:89:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "functionReturnParameters": 11783, "id": 11812, "nodeType": "Return", "src": "15375:96:86" } ] }, "documentation": { "id": 11775, "nodeType": "StructuredDocumentation", "src": "14794:350:86", "text": "@dev Returns whether the given spender can transfer a given token ID.\n@param spender address of the spender to query\n@param tokenId uint256 ID of the token to be transferred\n@return bool whether the msg.sender is approved for the given token ID,\nis an operator of the owner, or is the owner of the token" }, "id": 11814, "implemented": true, "kind": "function", "modifiers": [], "name": "_isApprovedOrOwner", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11780, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11777, "mutability": "mutable", "name": "spender", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11814, "src": "15177:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11776, "name": "address", "nodeType": "ElementaryTypeName", "src": "15177:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11779, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11814, "src": "15194:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11778, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "15194:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "15176:34:86" }, "returnParameters": { "id": 11783, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11782, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11814, "src": "15234:4:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 11781, "name": "bool", "nodeType": "ElementaryTypeName", "src": "15234:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" } ], "src": "15233:6:86" }, "scope": 12203, "src": "15149:329:86", "stateMutability": "view", "virtual": false, "visibility": "internal" }, { "body": { "id": 11828, "nodeType": "Block", "src": "16072:43:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11823, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11817, "src": "16092:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11824, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11819, "src": "16096:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "hexValue": "", "id": 11825, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "16105:2:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "typeString": "literal_string \"\"" }, "value": "" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_stringliteral_c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470", "typeString": "literal_string \"\"" } ], "id": 11822, "name": "_safeMint", "nodeType": "Identifier", "overloadedDeclarations": [ 11829, 11858 ], "referencedDeclaration": 11858, "src": "16082:9:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$__$", "typeString": "function (address,uint256,bytes memory)" } }, "id": 11826, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "16082:26:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11827, "nodeType": "ExpressionStatement", "src": "16082:26:86" } ] }, "documentation": { "id": 11815, "nodeType": "StructuredDocumentation", "src": "15484:518:86", "text": "@dev Internal function to safely mint a new token.\nReverts if the given token ID already exists.\nIf the target address is a contract, it must implement `onERC721Received`,\nwhich is called upon a safe transfer, and return the magic value\n`bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\nthe transfer is reverted.\n@param to The address that will own the minted token\n@param tokenId uint256 ID of the token to be minted" }, "id": 11829, "implemented": true, "kind": "function", "modifiers": [], "name": "_safeMint", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11820, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11817, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11829, "src": "16026:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11816, "name": "address", "nodeType": "ElementaryTypeName", "src": "16026:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11819, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11829, "src": "16038:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11818, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "16038:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "16025:29:86" }, "returnParameters": { "id": 11821, "nodeType": "ParameterList", "parameters": [], "src": "16072:0:86" }, "scope": 12203, "src": "16007:108:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 11857, "nodeType": "Block", "src": "16801:162:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11840, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11832, "src": "16817:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11841, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11834, "src": "16821:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11839, "name": "_mint", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11917, "src": "16811:5:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,uint256)" } }, "id": 11842, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "16811:18:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11843, "nodeType": "ExpressionStatement", "src": "16811:18:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11848, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "16878:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11847, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "16870:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11846, "name": "address", "nodeType": "ElementaryTypeName", "src": "16870:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11849, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "16870:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11850, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11832, "src": "16882:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11851, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11834, "src": "16886:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 11852, "name": "_data", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11836, "src": "16895:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "id": 11845, "name": "_checkOnERC721Received", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12165, "src": "16847:22:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$_t_bool_$", "typeString": "function (address,address,uint256,bytes memory) returns (bool)" } }, "id": 11853, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "16847:54:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e746572", "id": 11854, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "16903:52:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" }, "value": "ERC721: transfer to non ERC721Receiver implementer" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" } ], "id": 11844, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "16839:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11855, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "16839:117:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11856, "nodeType": "ExpressionStatement", "src": "16839:117:86" } ] }, "documentation": { "id": 11830, "nodeType": "StructuredDocumentation", "src": "16121:590:86", "text": "@dev Internal function to safely mint a new token.\nReverts if the given token ID already exists.\nIf the target address is a contract, it must implement `onERC721Received`,\nwhich is called upon a safe transfer, and return the magic value\n`bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`; otherwise,\nthe transfer is reverted.\n@param to The address that will own the minted token\n@param tokenId uint256 ID of the token to be minted\n@param _data bytes data to send along with a safe transfer check" }, "id": 11858, "implemented": true, "kind": "function", "modifiers": [], "name": "_safeMint", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11837, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11832, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11858, "src": "16735:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11831, "name": "address", "nodeType": "ElementaryTypeName", "src": "16735:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11834, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11858, "src": "16747:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11833, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "16747:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11836, "mutability": "mutable", "name": "_data", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11858, "src": "16764:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes" }, "typeName": { "id": 11835, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "16764:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes" } }, "value": null, "visibility": "internal" } ], "src": "16734:49:86" }, "returnParameters": { "id": 11838, "nodeType": "ParameterList", "parameters": [], "src": "16801:0:86" }, "scope": 12203, "src": "16716:247:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 11916, "nodeType": "Block", "src": "17269:332:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 11872, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 11867, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11861, "src": "17287:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11870, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "17301:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11869, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "17293:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11868, "name": "address", "nodeType": "ElementaryTypeName", "src": "17293:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11871, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17293:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "src": "17287:16:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a206d696e7420746f20746865207a65726f2061646472657373", "id": 11873, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "17305:34:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_8a66f4bb6512ffbfcc3db9b42318eb65f26ac15163eaa9a1e5cfa7bee9d1c7c6", "typeString": "literal_string \"ERC721: mint to the zero address\"" }, "value": "ERC721: mint to the zero address" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_8a66f4bb6512ffbfcc3db9b42318eb65f26ac15163eaa9a1e5cfa7bee9d1c7c6", "typeString": "literal_string \"ERC721: mint to the zero address\"" } ], "id": 11866, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "17279:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11874, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17279:61:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11875, "nodeType": "ExpressionStatement", "src": "17279:61:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11880, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "UnaryOperation", "operator": "!", "prefix": true, "src": "17358:17:86", "subExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11878, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11863, "src": "17367:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11877, "name": "_exists", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11774, "src": "17359:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", "typeString": "function (uint256) view returns (bool)" } }, "id": 11879, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17359:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a20746f6b656e20616c7265616479206d696e746564", "id": 11881, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "17377:30:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_2a63ce106ef95058ed21fd07c42a10f11dc5c32ac13a4e847923f7759f635d57", "typeString": "literal_string \"ERC721: token already minted\"" }, "value": "ERC721: token already minted" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_2a63ce106ef95058ed21fd07c42a10f11dc5c32ac13a4e847923f7759f635d57", "typeString": "literal_string \"ERC721: token already minted\"" } ], "id": 11876, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "17350:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 11882, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17350:58:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11883, "nodeType": "ExpressionStatement", "src": "17350:58:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11887, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "17448:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11886, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "17440:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11885, "name": "address", "nodeType": "ElementaryTypeName", "src": "17440:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11888, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17440:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11889, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11861, "src": "17452:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11890, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11863, "src": "17456:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11884, "name": "_beforeTokenTransfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12198, "src": "17419:20:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11891, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17419:45:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11892, "nodeType": "ExpressionStatement", "src": "17419:45:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11897, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11863, "src": "17497:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11893, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "17475:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 11895, "indexExpression": { "argumentTypes": null, "id": 11894, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11861, "src": "17489:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "17475:17:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 11896, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "add", "nodeType": "MemberAccess", "referencedDeclaration": 14957, "src": "17475:21:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintSet_$14937_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer,uint256) returns (bool)" } }, "id": 11898, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17475:30:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 11899, "nodeType": "ExpressionStatement", "src": "17475:30:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11903, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11863, "src": "17533:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 11904, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11861, "src": "17542:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_address", "typeString": "address" } ], "expression": { "argumentTypes": null, "id": 11900, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "17516:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11902, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "set", "nodeType": "MemberAccess", "referencedDeclaration": 14491, "src": "17516:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$_t_address_$returns$_t_bool_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256,address) returns (bool)" } }, "id": 11905, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17516:29:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 11906, "nodeType": "ExpressionStatement", "src": "17516:29:86" }, { "eventCall": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11910, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "17578:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11909, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "17570:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11908, "name": "address", "nodeType": "ElementaryTypeName", "src": "17570:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11911, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17570:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11912, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11861, "src": "17582:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 11913, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11863, "src": "17586:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11907, "name": "Transfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12390, "src": "17561:8:86", "typeDescriptions": { "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11914, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17561:33:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11915, "nodeType": "EmitStatement", "src": "17556:38:86" } ] }, "documentation": { "id": 11859, "nodeType": "StructuredDocumentation", "src": "16969:234:86", "text": "@dev Internal function to mint a new token.\nReverts if the given token ID already exists.\n@param to The address that will own the minted token\n@param tokenId uint256 ID of the token to be minted" }, "id": 11917, "implemented": true, "kind": "function", "modifiers": [], "name": "_mint", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11864, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11861, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11917, "src": "17223:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11860, "name": "address", "nodeType": "ElementaryTypeName", "src": "17223:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11863, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11917, "src": "17235:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11862, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "17235:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "17222:29:86" }, "returnParameters": { "id": 11865, "nodeType": "ParameterList", "parameters": [], "src": "17269:0:86" }, "scope": 12203, "src": "17208:393:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 11984, "nodeType": "Block", "src": "17831:453:86", "statements": [ { "assignments": [ 11924 ], "declarations": [ { "constant": false, "id": 11924, "mutability": "mutable", "name": "owner", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11984, "src": "17841:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11923, "name": "address", "nodeType": "ElementaryTypeName", "src": "17841:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" } ], "id": 11928, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11926, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "17865:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11925, "name": "ownerOf", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11398, "src": "17857:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 11927, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17857:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "VariableDeclarationStatement", "src": "17841:32:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11930, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11924, "src": "17905:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11933, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "17920:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11932, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "17912:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11931, "name": "address", "nodeType": "ElementaryTypeName", "src": "17912:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11934, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17912:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11935, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "17924:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11929, "name": "_beforeTokenTransfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12198, "src": "17884:20:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11936, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17884:48:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11937, "nodeType": "ExpressionStatement", "src": "17884:48:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11941, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "17987:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11940, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "17979:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11939, "name": "address", "nodeType": "ElementaryTypeName", "src": "17979:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11942, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17979:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11943, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "17991:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11938, "name": "_approve", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12187, "src": "17970:8:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,uint256)" } }, "id": 11944, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "17970:29:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11945, "nodeType": "ExpressionStatement", "src": "17970:29:86" }, { "condition": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "id": 11954, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11948, "name": "_tokenURIs", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11294, "src": "18055:10:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string storage ref)" } }, "id": 11950, "indexExpression": { "argumentTypes": null, "id": 11949, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "18066:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "18055:19:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } ], "id": 11947, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "18049:5:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_bytes_storage_ptr_$", "typeString": "type(bytes storage pointer)" }, "typeName": { "id": 11946, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "18049:5:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11951, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18049:26:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes storage pointer" } }, "id": 11952, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "18049:33:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "hexValue": "30", "id": 11953, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "18086:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" }, "src": "18049:38:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": null, "id": 11961, "nodeType": "IfStatement", "src": "18045:95:86", "trueBody": { "id": 11960, "nodeType": "Block", "src": "18089:51:86", "statements": [ { "expression": { "argumentTypes": null, "id": 11958, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "UnaryOperation", "operator": "delete", "prefix": true, "src": "18103:26:86", "subExpression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11955, "name": "_tokenURIs", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11294, "src": "18110:10:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string storage ref)" } }, "id": 11957, "indexExpression": { "argumentTypes": null, "id": 11956, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "18121:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": true, "nodeType": "IndexAccess", "src": "18110:19:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11959, "nodeType": "ExpressionStatement", "src": "18103:26:86" } ] } }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11966, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "18178:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 11962, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "18150:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 11964, "indexExpression": { "argumentTypes": null, "id": 11963, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11924, "src": "18164:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "18150:20:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 11965, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "remove", "nodeType": "MemberAccess", "referencedDeclaration": 14977, "src": "18150:27:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintSet_$14937_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer,uint256) returns (bool)" } }, "id": 11967, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18150:36:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 11968, "nodeType": "ExpressionStatement", "src": "18150:36:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11972, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "18217:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "id": 11969, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "18197:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 11971, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "remove", "nodeType": "MemberAccess", "referencedDeclaration": 14511, "src": "18197:19:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256) returns (bool)" } }, "id": 11973, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18197:28:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 11974, "nodeType": "ExpressionStatement", "src": "18197:28:86" }, { "eventCall": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11976, "name": "owner", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11924, "src": "18250:5:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 11979, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "18265:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 11978, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "18257:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 11977, "name": "address", "nodeType": "ElementaryTypeName", "src": "18257:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 11980, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18257:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 11981, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11920, "src": "18269:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11975, "name": "Transfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12390, "src": "18241:8:86", "typeDescriptions": { "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 11982, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18241:36:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 11983, "nodeType": "EmitStatement", "src": "18236:41:86" } ] }, "documentation": { "id": 11918, "nodeType": "StructuredDocumentation", "src": "17607:170:86", "text": "@dev Internal function to burn a specific token.\nReverts if the token does not exist.\n@param tokenId uint256 ID of the token being burned" }, "id": 11985, "implemented": true, "kind": "function", "modifiers": [], "name": "_burn", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11921, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11920, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 11985, "src": "17797:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11919, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "17797:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "17796:17:86" }, "returnParameters": { "id": 11922, "nodeType": "ParameterList", "parameters": [], "src": "17831:0:86" }, "scope": 12203, "src": "17782:502:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 12055, "nodeType": "Block", "src": "18740:480:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 12000, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 11997, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "18766:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 11996, "name": "ownerOf", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11398, "src": "18758:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 11998, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18758:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "id": 11999, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11988, "src": "18778:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "18758:24:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e73666572206f6620746f6b656e2074686174206973206e6f74206f776e", "id": 12001, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "18784:43:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_a01073130a885d6c1c1af6ac75fc3b1c4f9403c235362962bbf528e2bd87d950", "typeString": "literal_string \"ERC721: transfer of token that is not own\"" }, "value": "ERC721: transfer of token that is not own" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_a01073130a885d6c1c1af6ac75fc3b1c4f9403c235362962bbf528e2bd87d950", "typeString": "literal_string \"ERC721: transfer of token that is not own\"" } ], "id": 11995, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "18750:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 12002, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18750:78:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12003, "nodeType": "ExpressionStatement", "src": "18750:78:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_address", "typeString": "address" }, "id": 12010, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 12005, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11990, "src": "18846:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "BinaryOperation", "operator": "!=", "rightExpression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 12008, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "18860:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 12007, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "18852:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 12006, "name": "address", "nodeType": "ElementaryTypeName", "src": "18852:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 12009, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18852:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, "src": "18846:16:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732313a207472616e7366657220746f20746865207a65726f2061646472657373", "id": 12011, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "18864:38:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_455fea98ea03c32d7dd1a6f1426917d80529bf47b3ccbde74e7206e889e709f4", "typeString": "literal_string \"ERC721: transfer to the zero address\"" }, "value": "ERC721: transfer to the zero address" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_455fea98ea03c32d7dd1a6f1426917d80529bf47b3ccbde74e7206e889e709f4", "typeString": "literal_string \"ERC721: transfer to the zero address\"" } ], "id": 12004, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "18838:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 12012, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18838:65:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12013, "nodeType": "ExpressionStatement", "src": "18838:65:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12015, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11988, "src": "18935:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12016, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11990, "src": "18941:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12017, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "18945:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12014, "name": "_beforeTokenTransfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12198, "src": "18914:20:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 12018, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "18914:39:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12019, "nodeType": "ExpressionStatement", "src": "18914:39:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "30", "id": 12023, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "19032:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" } ], "id": 12022, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "19024:7:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_address_$", "typeString": "type(address)" }, "typeName": { "id": 12021, "name": "address", "nodeType": "ElementaryTypeName", "src": "19024:7:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } }, "id": 12024, "isConstant": false, "isLValue": false, "isPure": true, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19024:10:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 12025, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "19036:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12020, "name": "_approve", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12187, "src": "19015:8:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,uint256)" } }, "id": 12026, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19015:29:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12027, "nodeType": "ExpressionStatement", "src": "19015:29:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12032, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "19082:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 12028, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "19055:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 12030, "indexExpression": { "argumentTypes": null, "id": 12029, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11988, "src": "19069:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "19055:19:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 12031, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "remove", "nodeType": "MemberAccess", "referencedDeclaration": 14977, "src": "19055:26:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintSet_$14937_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer,uint256) returns (bool)" } }, "id": 12033, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19055:35:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 12034, "nodeType": "ExpressionStatement", "src": "19055:35:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12039, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "19122:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "expression": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 12035, "name": "_holderTokens", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11274, "src": "19100:13:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_address_$_t_struct$_UintSet_$14937_storage_$", "typeString": "mapping(address => struct EnumerableSet.UintSet storage ref)" } }, "id": 12037, "indexExpression": { "argumentTypes": null, "id": 12036, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11990, "src": "19114:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "nodeType": "IndexAccess", "src": "19100:17:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintSet_$14937_storage", "typeString": "struct EnumerableSet.UintSet storage ref" } }, "id": 12038, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "add", "nodeType": "MemberAccess", "referencedDeclaration": 14957, "src": "19100:21:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintSet_$14937_storage_ptr_$_t_uint256_$returns$_t_bool_$bound_to$_t_struct$_UintSet_$14937_storage_ptr_$", "typeString": "function (struct EnumerableSet.UintSet storage pointer,uint256) returns (bool)" } }, "id": 12040, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19100:30:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 12041, "nodeType": "ExpressionStatement", "src": "19100:30:86" }, { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12045, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "19158:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 12046, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11990, "src": "19167:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_address", "typeString": "address" } ], "expression": { "argumentTypes": null, "id": 12042, "name": "_tokenOwners", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11276, "src": "19141:12:86", "typeDescriptions": { "typeIdentifier": "t_struct$_UintToAddressMap_$14462_storage", "typeString": "struct EnumerableMap.UintToAddressMap storage ref" } }, "id": 12044, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": false, "memberName": "set", "nodeType": "MemberAccess", "referencedDeclaration": 14491, "src": "19141:16:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_nonpayable$_t_struct$_UintToAddressMap_$14462_storage_ptr_$_t_uint256_$_t_address_$returns$_t_bool_$bound_to$_t_struct$_UintToAddressMap_$14462_storage_ptr_$", "typeString": "function (struct EnumerableMap.UintToAddressMap storage pointer,uint256,address) returns (bool)" } }, "id": 12047, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19141:29:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "id": 12048, "nodeType": "ExpressionStatement", "src": "19141:29:86" }, { "eventCall": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12050, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11988, "src": "19195:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12051, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11990, "src": "19201:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12052, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11992, "src": "19205:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12049, "name": "Transfer", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12390, "src": "19186:8:86", "typeDescriptions": { "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 12053, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19186:27:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12054, "nodeType": "EmitStatement", "src": "19181:32:86" } ] }, "documentation": { "id": 11986, "nodeType": "StructuredDocumentation", "src": "18290:366:86", "text": "@dev Internal function to transfer ownership of a given token ID to another address.\nAs opposed to {transferFrom}, this imposes no restrictions on msg.sender.\n@param from current owner of the token\n@param to address to receive the ownership of the given token ID\n@param tokenId uint256 ID of the token to be transferred" }, "id": 12056, "implemented": true, "kind": "function", "modifiers": [], "name": "_transfer", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 11993, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 11988, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12056, "src": "18680:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11987, "name": "address", "nodeType": "ElementaryTypeName", "src": "18680:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11990, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12056, "src": "18694:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 11989, "name": "address", "nodeType": "ElementaryTypeName", "src": "18694:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 11992, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12056, "src": "18706:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 11991, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "18706:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "18679:43:86" }, "returnParameters": { "id": 11994, "nodeType": "ParameterList", "parameters": [], "src": "18740:0:86" }, "scope": 12203, "src": "18661:559:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 12077, "nodeType": "Block", "src": "19634:131:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12066, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12059, "src": "19660:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12065, "name": "_exists", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11774, "src": "19652:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_bool_$", "typeString": "function (uint256) view returns (bool)" } }, "id": 12067, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19652:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, { "argumentTypes": null, "hexValue": "4552433732314d657461646174613a2055524920736574206f66206e6f6e6578697374656e7420746f6b656e", "id": 12068, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "19670:46:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_94be4a260caaeac1b145f03ffa2e70bc612b64982d04f24073aaf3a5f9009978", "typeString": "literal_string \"ERC721Metadata: URI set of nonexistent token\"" }, "value": "ERC721Metadata: URI set of nonexistent token" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bool", "typeString": "bool" }, { "typeIdentifier": "t_stringliteral_94be4a260caaeac1b145f03ffa2e70bc612b64982d04f24073aaf3a5f9009978", "typeString": "literal_string \"ERC721Metadata: URI set of nonexistent token\"" } ], "id": 12064, "name": "require", "nodeType": "Identifier", "overloadedDeclarations": [ -18, -18 ], "referencedDeclaration": -18, "src": "19644:7:86", "typeDescriptions": { "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", "typeString": "function (bool,string memory) pure" } }, "id": 12069, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "19644:73:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12070, "nodeType": "ExpressionStatement", "src": "19644:73:86" }, { "expression": { "argumentTypes": null, "id": 12075, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 12071, "name": "_tokenURIs", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11294, "src": "19727:10:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_string_storage_$", "typeString": "mapping(uint256 => string storage ref)" } }, "id": 12073, "indexExpression": { "argumentTypes": null, "id": 12072, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12059, "src": "19738:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": true, "nodeType": "IndexAccess", "src": "19727:19:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 12074, "name": "_tokenURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12061, "src": "19749:9:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "src": "19727:31:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "id": 12076, "nodeType": "ExpressionStatement", "src": "19727:31:86" } ] }, "documentation": { "id": 12057, "nodeType": "StructuredDocumentation", "src": "19226:322:86", "text": "@dev Internal function to set the token URI for a given token.\n * Reverts if the token ID does not exist.\n * TIP: If all token IDs share a prefix (for example, if your URIs look like\n`https://api.myproject.com/token/`), use {_setBaseURI} to store\nit and save gas." }, "id": 12078, "implemented": true, "kind": "function", "modifiers": [], "name": "_setTokenURI", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 12062, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12059, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12078, "src": "19575:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 12058, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "19575:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12061, "mutability": "mutable", "name": "_tokenURI", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12078, "src": "19592:23:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 12060, "name": "string", "nodeType": "ElementaryTypeName", "src": "19592:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "19574:42:86" }, "returnParameters": { "id": 12063, "nodeType": "ParameterList", "parameters": [], "src": "19634:0:86" }, "scope": 12203, "src": "19553:212:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 12088, "nodeType": "Block", "src": "20050:36:86", "statements": [ { "expression": { "argumentTypes": null, "id": 12086, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "id": 12084, "name": "_baseURI", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11296, "src": "20060:8:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 12085, "name": "baseURI_", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12081, "src": "20071:8:86", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string memory" } }, "src": "20060:19:86", "typeDescriptions": { "typeIdentifier": "t_string_storage", "typeString": "string storage ref" } }, "id": 12087, "nodeType": "ExpressionStatement", "src": "20060:19:86" } ] }, "documentation": { "id": 12079, "nodeType": "StructuredDocumentation", "src": "19771:212:86", "text": "@dev Internal function to set the base URI for all token IDs. It is\nautomatically added as a prefix to the value returned in {tokenURI},\nor to the token ID if {tokenURI} is empty." }, "id": 12089, "implemented": true, "kind": "function", "modifiers": [], "name": "_setBaseURI", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 12082, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12081, "mutability": "mutable", "name": "baseURI_", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12089, "src": "20009:22:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_string_memory_ptr", "typeString": "string" }, "typeName": { "id": 12080, "name": "string", "nodeType": "ElementaryTypeName", "src": "20009:6:86", "typeDescriptions": { "typeIdentifier": "t_string_storage_ptr", "typeString": "string" } }, "value": null, "visibility": "internal" } ], "src": "20008:24:86" }, "returnParameters": { "id": 12083, "nodeType": "ParameterList", "parameters": [], "src": "20050:0:86" }, "scope": 12203, "src": "19988:98:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "body": { "id": 12164, "nodeType": "Block", "src": "20769:920:86", "statements": [ { "condition": { "argumentTypes": null, "id": 12106, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "UnaryOperation", "operator": "!", "prefix": true, "src": "20783:16:86", "subExpression": { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "expression": { "argumentTypes": null, "id": 12103, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12094, "src": "20784:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "id": 12104, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "isContract", "nodeType": "MemberAccess", "referencedDeclaration": 13902, "src": "20784:13:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_address_$returns$_t_bool_$bound_to$_t_address_$", "typeString": "function (address) view returns (bool)" } }, "id": 12105, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "20784:15:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": null, "id": 12110, "nodeType": "IfStatement", "src": "20779:58:86", "trueBody": { "id": 12109, "nodeType": "Block", "src": "20801:36:86", "statements": [ { "expression": { "argumentTypes": null, "hexValue": "74727565", "id": 12107, "isConstant": false, "isLValue": false, "isPure": true, "kind": "bool", "lValueRequested": false, "nodeType": "Literal", "src": "20822:4:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "value": "true" }, "functionReturnParameters": 12102, "id": 12108, "nodeType": "Return", "src": "20815:11:86" } ] } }, { "assignments": [ 12112, 12114 ], "declarations": [ { "constant": false, "id": 12112, "mutability": "mutable", "name": "success", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12164, "src": "20906:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 12111, "name": "bool", "nodeType": "ElementaryTypeName", "src": "20906:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12114, "mutability": "mutable", "name": "returndata", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12164, "src": "20920:23:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes" }, "typeName": { "id": 12113, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "20920:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes" } }, "value": null, "visibility": "internal" } ], "id": 12131, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "expression": { "argumentTypes": null, "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12120, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12094, "src": "21007:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" } ], "id": 12119, "name": "IERC721Receiver", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12554, "src": "20991:15:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_contract$_IERC721Receiver_$12554_$", "typeString": "type(contract IERC721Receiver)" } }, "id": 12121, "isConstant": false, "isLValue": false, "isPure": false, "kind": "typeConversion", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "20991:19:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_contract$_IERC721Receiver_$12554", "typeString": "contract IERC721Receiver" } }, "id": 12122, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "onERC721Received", "nodeType": "MemberAccess", "referencedDeclaration": 12553, "src": "20991:36:86", "typeDescriptions": { "typeIdentifier": "t_function_external_nonpayable$_t_address_$_t_address_$_t_uint256_$_t_bytes_memory_ptr_$returns$_t_bytes4_$", "typeString": "function (address,address,uint256,bytes memory) external returns (bytes4)" } }, "id": 12123, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "selector", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "20991:45:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, { "argumentTypes": null, "arguments": [], "expression": { "argumentTypes": [], "id": 12124, "name": "_msgSender", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 28, "src": "21050:10:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$__$returns$_t_address_payable_$", "typeString": "function () view returns (address payable)" } }, "id": 12125, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "21050:12:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address_payable", "typeString": "address payable" } }, { "argumentTypes": null, "id": 12126, "name": "from", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12092, "src": "21076:4:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12127, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12096, "src": "21094:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, { "argumentTypes": null, "id": 12128, "name": "_data", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12098, "src": "21115:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, { "typeIdentifier": "t_address_payable", "typeString": "address payable" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" }, { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "expression": { "argumentTypes": null, "id": 12117, "name": "abi", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": -1, "src": "20955:3:86", "typeDescriptions": { "typeIdentifier": "t_magic_abi", "typeString": "abi" } }, "id": 12118, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "memberName": "encodeWithSelector", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "20955:22:86", "typeDescriptions": { "typeIdentifier": "t_function_abiencodewithselector_pure$_t_bytes4_$returns$_t_bytes_memory_ptr_$", "typeString": "function (bytes4) pure returns (bytes memory)" } }, "id": 12129, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "20955:175:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } ], "expression": { "argumentTypes": null, "id": 12115, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12094, "src": "20947:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "id": 12116, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "call", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "20947:7:86", "typeDescriptions": { "typeIdentifier": "t_function_barecall_payable$_t_bytes_memory_ptr_$returns$_t_bool_$_t_bytes_memory_ptr_$", "typeString": "function (bytes memory) payable returns (bool,bytes memory)" } }, "id": 12130, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "20947:184:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$_t_bool_$_t_bytes_memory_ptr_$", "typeString": "tuple(bool,bytes memory)" } }, "nodeType": "VariableDeclarationStatement", "src": "20905:226:86" }, { "condition": { "argumentTypes": null, "id": 12133, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "UnaryOperation", "operator": "!", "prefix": true, "src": "21145:8:86", "subExpression": { "argumentTypes": null, "id": 12132, "name": "success", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12112, "src": "21146:7:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": { "id": 12162, "nodeType": "Block", "src": "21561:122:86", "statements": [ { "assignments": [ 12148 ], "declarations": [ { "constant": false, "id": 12148, "mutability": "mutable", "name": "retval", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12162, "src": "21575:13:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "typeName": { "id": 12147, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "21575:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "value": null, "visibility": "internal" } ], "id": 12156, "initialValue": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12151, "name": "returndata", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12114, "src": "21602:10:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } }, { "argumentTypes": null, "components": [ { "argumentTypes": null, "id": 12153, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "ElementaryTypeNameExpression", "src": "21615:6:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_bytes4_$", "typeString": "type(bytes4)" }, "typeName": { "id": 12152, "name": "bytes4", "nodeType": "ElementaryTypeName", "src": "21615:6:86", "typeDescriptions": { "typeIdentifier": null, "typeString": null } } } ], "id": 12154, "isConstant": false, "isInlineArray": false, "isLValue": false, "isPure": true, "lValueRequested": false, "nodeType": "TupleExpression", "src": "21614:8:86", "typeDescriptions": { "typeIdentifier": "t_type$_t_bytes4_$", "typeString": "type(bytes4)" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" }, { "typeIdentifier": "t_type$_t_bytes4_$", "typeString": "type(bytes4)" } ], "expression": { "argumentTypes": null, "id": 12149, "name": "abi", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": -1, "src": "21591:3:86", "typeDescriptions": { "typeIdentifier": "t_magic_abi", "typeString": "abi" } }, "id": 12150, "isConstant": false, "isLValue": false, "isPure": true, "lValueRequested": false, "memberName": "decode", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "21591:10:86", "typeDescriptions": { "typeIdentifier": "t_function_abidecode_pure$__$returns$__$", "typeString": "function () pure" } }, "id": 12155, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "21591:32:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "nodeType": "VariableDeclarationStatement", "src": "21575:48:86" }, { "expression": { "argumentTypes": null, "components": [ { "argumentTypes": null, "commonType": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" }, "id": 12159, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "id": 12157, "name": "retval", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12148, "src": "21645:6:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "nodeType": "BinaryOperation", "operator": "==", "rightExpression": { "argumentTypes": null, "id": 12158, "name": "_ERC721_RECEIVED", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11270, "src": "21655:16:86", "typeDescriptions": { "typeIdentifier": "t_bytes4", "typeString": "bytes4" } }, "src": "21645:26:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } } ], "id": 12160, "isConstant": false, "isInlineArray": false, "isLValue": false, "isPure": false, "lValueRequested": false, "nodeType": "TupleExpression", "src": "21644:28:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "functionReturnParameters": 12102, "id": 12161, "nodeType": "Return", "src": "21637:35:86" } ] }, "id": 12163, "nodeType": "IfStatement", "src": "21141:542:86", "trueBody": { "id": 12146, "nodeType": "Block", "src": "21155:400:86", "statements": [ { "condition": { "argumentTypes": null, "commonType": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "id": 12137, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftExpression": { "argumentTypes": null, "expression": { "argumentTypes": null, "id": 12134, "name": "returndata", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12114, "src": "21173:10:86", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes memory" } }, "id": 12135, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "memberName": "length", "nodeType": "MemberAccess", "referencedDeclaration": null, "src": "21173:17:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "nodeType": "BinaryOperation", "operator": ">", "rightExpression": { "argumentTypes": null, "hexValue": "30", "id": 12136, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "21193:1:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_0_by_1", "typeString": "int_const 0" }, "value": "0" }, "src": "21173:21:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "falseBody": { "id": 12144, "nodeType": "Block", "src": "21452:93:86", "statements": [ { "expression": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "hexValue": "4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e746572", "id": 12141, "isConstant": false, "isLValue": false, "isPure": true, "kind": "string", "lValueRequested": false, "nodeType": "Literal", "src": "21477:52:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" }, "value": "ERC721: transfer to non ERC721Receiver implementer" } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_stringliteral_1e766a06da43a53d0f4c380e06e5a342e14d5af1bf8501996c844905530ca84e", "typeString": "literal_string \"ERC721: transfer to non ERC721Receiver implementer\"" } ], "id": 12140, "name": "revert", "nodeType": "Identifier", "overloadedDeclarations": [ -19, -19 ], "referencedDeclaration": -19, "src": "21470:6:86", "typeDescriptions": { "typeIdentifier": "t_function_revert_pure$_t_string_memory_ptr_$returns$__$", "typeString": "function (string memory) pure" } }, "id": 12142, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "21470:60:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12143, "nodeType": "ExpressionStatement", "src": "21470:60:86" } ] }, "id": 12145, "nodeType": "IfStatement", "src": "21169:376:86", "trueBody": { "id": 12139, "nodeType": "Block", "src": "21196:250:86", "statements": [ { "AST": { "nodeType": "YulBlock", "src": "21287:145:86", "statements": [ { "nodeType": "YulVariableDeclaration", "src": "21309:40:86", "value": { "arguments": [ { "name": "returndata", "nodeType": "YulIdentifier", "src": "21338:10:86" } ], "functionName": { "name": "mload", "nodeType": "YulIdentifier", "src": "21332:5:86" }, "nodeType": "YulFunctionCall", "src": "21332:17:86" }, "variables": [ { "name": "returndata_size", "nodeType": "YulTypedName", "src": "21313:15:86", "type": "" } ] }, { "expression": { "arguments": [ { "arguments": [ { "kind": "number", "nodeType": "YulLiteral", "src": "21381:2:86", "type": "", "value": "32" }, { "name": "returndata", "nodeType": "YulIdentifier", "src": "21385:10:86" } ], "functionName": { "name": "add", "nodeType": "YulIdentifier", "src": "21377:3:86" }, "nodeType": "YulFunctionCall", "src": "21377:19:86" }, { "name": "returndata_size", "nodeType": "YulIdentifier", "src": "21398:15:86" } ], "functionName": { "name": "revert", "nodeType": "YulIdentifier", "src": "21370:6:86" }, "nodeType": "YulFunctionCall", "src": "21370:44:86" }, "nodeType": "YulExpressionStatement", "src": "21370:44:86" } ] }, "evmVersion": "petersburg", "externalReferences": [ { "declaration": 12114, "isOffset": false, "isSlot": false, "src": "21338:10:86", "valueSize": 1 }, { "declaration": 12114, "isOffset": false, "isSlot": false, "src": "21385:10:86", "valueSize": 1 } ], "id": 12138, "nodeType": "InlineAssembly", "src": "21278:154:86" } ] } } ] } } ] }, "documentation": { "id": 12090, "nodeType": "StructuredDocumentation", "src": "20092:542:86", "text": "@dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\nThe call is not executed if the target address is not a contract.\n * @param from address representing the previous owner of the given token ID\n@param to target address that will receive the tokens\n@param tokenId uint256 ID of the token to be transferred\n@param _data bytes optional data to send along with the call\n@return bool whether the call correctly returned the expected magic value" }, "id": 12165, "implemented": true, "kind": "function", "modifiers": [], "name": "_checkOnERC721Received", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 12099, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12092, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12165, "src": "20671:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 12091, "name": "address", "nodeType": "ElementaryTypeName", "src": "20671:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12094, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12165, "src": "20685:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 12093, "name": "address", "nodeType": "ElementaryTypeName", "src": "20685:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12096, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12165, "src": "20697:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 12095, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "20697:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12098, "mutability": "mutable", "name": "_data", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12165, "src": "20714:18:86", "stateVariable": false, "storageLocation": "memory", "typeDescriptions": { "typeIdentifier": "t_bytes_memory_ptr", "typeString": "bytes" }, "typeName": { "id": 12097, "name": "bytes", "nodeType": "ElementaryTypeName", "src": "20714:5:86", "typeDescriptions": { "typeIdentifier": "t_bytes_storage_ptr", "typeString": "bytes" } }, "value": null, "visibility": "internal" } ], "src": "20670:63:86" }, "returnParameters": { "id": 12102, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12101, "mutability": "mutable", "name": "", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12165, "src": "20759:4:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" }, "typeName": { "id": 12100, "name": "bool", "nodeType": "ElementaryTypeName", "src": "20759:4:86", "typeDescriptions": { "typeIdentifier": "t_bool", "typeString": "bool" } }, "value": null, "visibility": "internal" } ], "src": "20758:6:86" }, "scope": 12203, "src": "20639:1050:86", "stateMutability": "nonpayable", "virtual": false, "visibility": "private" }, { "body": { "id": 12186, "nodeType": "Block", "src": "21750:100:86", "statements": [ { "expression": { "argumentTypes": null, "id": 12176, "isConstant": false, "isLValue": false, "isPure": false, "lValueRequested": false, "leftHandSide": { "argumentTypes": null, "baseExpression": { "argumentTypes": null, "id": 12172, "name": "_tokenApprovals", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11280, "src": "21760:15:86", "typeDescriptions": { "typeIdentifier": "t_mapping$_t_uint256_$_t_address_$", "typeString": "mapping(uint256 => address)" } }, "id": 12174, "indexExpression": { "argumentTypes": null, "id": 12173, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12169, "src": "21776:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "isConstant": false, "isLValue": true, "isPure": false, "lValueRequested": true, "nodeType": "IndexAccess", "src": "21760:24:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "nodeType": "Assignment", "operator": "=", "rightHandSide": { "argumentTypes": null, "id": 12175, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12167, "src": "21787:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "src": "21760:29:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "id": 12177, "nodeType": "ExpressionStatement", "src": "21760:29:86" }, { "eventCall": { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "arguments": [ { "argumentTypes": null, "id": 12180, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12169, "src": "21821:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12179, "name": "ownerOf", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 11398, "src": "21813:7:86", "typeDescriptions": { "typeIdentifier": "t_function_internal_view$_t_uint256_$returns$_t_address_$", "typeString": "function (uint256) view returns (address)" } }, "id": 12181, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "21813:16:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12182, "name": "to", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12167, "src": "21831:2:86", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, { "argumentTypes": null, "id": 12183, "name": "tokenId", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12169, "src": "21835:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } } ], "expression": { "argumentTypes": [ { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_address", "typeString": "address" }, { "typeIdentifier": "t_uint256", "typeString": "uint256" } ], "id": 12178, "name": "Approval", "nodeType": "Identifier", "overloadedDeclarations": [], "referencedDeclaration": 12398, "src": "21804:8:86", "typeDescriptions": { "typeIdentifier": "t_function_event_nonpayable$_t_address_$_t_address_$_t_uint256_$returns$__$", "typeString": "function (address,address,uint256)" } }, "id": 12184, "isConstant": false, "isLValue": false, "isPure": false, "kind": "functionCall", "lValueRequested": false, "names": [], "nodeType": "FunctionCall", "src": "21804:39:86", "tryCall": false, "typeDescriptions": { "typeIdentifier": "t_tuple$__$", "typeString": "tuple()" } }, "id": 12185, "nodeType": "EmitStatement", "src": "21799:44:86" } ] }, "documentation": null, "id": 12187, "implemented": true, "kind": "function", "modifiers": [], "name": "_approve", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 12170, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12167, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12187, "src": "21713:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 12166, "name": "address", "nodeType": "ElementaryTypeName", "src": "21713:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12169, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12187, "src": "21725:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 12168, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "21725:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "21712:29:86" }, "returnParameters": { "id": 12171, "nodeType": "ParameterList", "parameters": [], "src": "21750:0:86" }, "scope": 12203, "src": "21695:155:86", "stateMutability": "nonpayable", "virtual": false, "visibility": "private" }, { "body": { "id": 12197, "nodeType": "Block", "src": "22496:3:86", "statements": [] }, "documentation": { "id": 12188, "nodeType": "StructuredDocumentation", "src": "21856:545:86", "text": "@dev Hook that is called before any token transfer. This includes minting\nand burning.\n * Calling conditions:\n * - when `from` and `to` are both non-zero, ``from``'s `tokenId` will be\ntransferred to `to`.\n- when `from` is zero, `tokenId` will be minted for `to`.\n- when `to` is zero, ``from``'s `tokenId` will be burned.\n- `from` and `to` are never both zero.\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]." }, "id": 12198, "implemented": true, "kind": "function", "modifiers": [], "name": "_beforeTokenTransfer", "nodeType": "FunctionDefinition", "overrides": null, "parameters": { "id": 12195, "nodeType": "ParameterList", "parameters": [ { "constant": false, "id": 12190, "mutability": "mutable", "name": "from", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12198, "src": "22436:12:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 12189, "name": "address", "nodeType": "ElementaryTypeName", "src": "22436:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12192, "mutability": "mutable", "name": "to", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12198, "src": "22450:10:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" }, "typeName": { "id": 12191, "name": "address", "nodeType": "ElementaryTypeName", "src": "22450:7:86", "stateMutability": "nonpayable", "typeDescriptions": { "typeIdentifier": "t_address", "typeString": "address" } }, "value": null, "visibility": "internal" }, { "constant": false, "id": 12194, "mutability": "mutable", "name": "tokenId", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12198, "src": "22462:15:86", "stateVariable": false, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" }, "typeName": { "id": 12193, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "22462:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "value": null, "visibility": "internal" } ], "src": "22435:43:86" }, "returnParameters": { "id": 12196, "nodeType": "ParameterList", "parameters": [], "src": "22496:0:86" }, "scope": 12203, "src": "22406:93:86", "stateMutability": "nonpayable", "virtual": true, "visibility": "internal" }, { "constant": false, "id": 12202, "mutability": "mutable", "name": "__gap", "nodeType": "VariableDeclaration", "overrides": null, "scope": 12203, "src": "22505:25:86", "stateVariable": true, "storageLocation": "default", "typeDescriptions": { "typeIdentifier": "t_array$_t_uint256_$41_storage", "typeString": "uint256[41]" }, "typeName": { "baseType": { "id": 12199, "name": "uint256", "nodeType": "ElementaryTypeName", "src": "22505:7:86", "typeDescriptions": { "typeIdentifier": "t_uint256", "typeString": "uint256" } }, "id": 12201, "length": { "argumentTypes": null, "hexValue": "3431", "id": 12200, "isConstant": false, "isLValue": false, "isPure": true, "kind": "number", "lValueRequested": false, "nodeType": "Literal", "src": "22513:2:86", "subdenomination": null, "typeDescriptions": { "typeIdentifier": "t_rational_41_by_1", "typeString": "int_const 41" }, "value": "41" }, "nodeType": "ArrayTypeName", "src": "22505:11:86", "typeDescriptions": { "typeIdentifier": "t_array$_t_uint256_$41_storage_ptr", "typeString": "uint256[41]" } }, "value": null, "visibility": "private" } ], "scope": 12204, "src": "562:21971:86" } ], "src": "0:22534:86" }, "bytecode": "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", "deployedBytecode": "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", "compiler": { "name": "solc", "version": "0.6.7+commit.b8d736ae.Emscripten.clang", "optimizer": { "enabled": true, "runs": 200 }, "evmVersion": "petersburg" } }