1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0x91a97a6822contract TokenProperties is Dummy, ERC165 {23 /// @notice Set permissions for token property.24 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.25 /// @param key Property key.26 /// @param isMutable Permission to mutate property.27 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.29 /// @dev EVM selector for this function is: 0x222d97fa,30 /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31 function setTokenPropertyPermission(32 string memory key,33 bool isMutable,34 bool collectionAdmin,35 bool tokenOwner36 ) public {37 require(false, stub_error);38 key;39 isMutable;40 collectionAdmin;41 tokenOwner;42 dummy = 0;43 }4445 // /// @notice Set token property value.46 // /// @dev Throws error if `msg.sender` has no permission to edit the property.47 // /// @param tokenId ID of the token.48 // /// @param key Property key.49 // /// @param value Property value.50 // /// @dev EVM selector for this function is: 0x1752d67b,51 // /// or in textual repr: setProperty(uint256,string,bytes)52 // function setProperty(uint256 tokenId, string memory key, bytes memory value) public {53 // require(false, stub_error);54 // tokenId;55 // key;56 // value;57 // dummy = 0;58 // }5960 /// @notice Set token properties value.61 /// @dev Throws error if `msg.sender` has no permission to edit the property.62 /// @param tokenId ID of the token.63 /// @param properties settable properties64 /// @dev EVM selector for this function is: 0x14ed3a6e,65 /// or in textual repr: setProperties(uint256,(string,bytes)[])66 function setProperties(uint256 tokenId, Property[] memory properties) public {67 require(false, stub_error);68 tokenId;69 properties;70 dummy = 0;71 }7273 // /// @notice Delete token property value.74 // /// @dev Throws error if `msg.sender` has no permission to edit the property.75 // /// @param tokenId ID of the token.76 // /// @param key Property key.77 // /// @dev EVM selector for this function is: 0x066111d1,78 // /// or in textual repr: deleteProperty(uint256,string)79 // function deleteProperty(uint256 tokenId, string memory key) public {80 // require(false, stub_error);81 // tokenId;82 // key;83 // dummy = 0;84 // }8586 /// @notice Delete token properties value.87 /// @dev Throws error if `msg.sender` has no permission to edit the property.88 /// @param tokenId ID of the token.89 /// @param keys Properties key.90 /// @dev EVM selector for this function is: 0xc472d371,91 /// or in textual repr: deleteProperties(uint256,string[])92 function deleteProperties(uint256 tokenId, string[] memory keys) public {93 require(false, stub_error);94 tokenId;95 keys;96 dummy = 0;97 }9899 /// @notice Get token property value.100 /// @dev Throws error if key not found101 /// @param tokenId ID of the token.102 /// @param key Property key.103 /// @return Property value bytes104 /// @dev EVM selector for this function is: 0x7228c327,105 /// or in textual repr: property(uint256,string)106 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107 require(false, stub_error);108 tokenId;109 key;110 dummy;111 return hex"";112 }113}114115/// @dev Property struct116struct Property {117 string key;118 bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0x324a7f5b123contract Collection is Dummy, ERC165 {124 // /// Set collection property.125 // ///126 // /// @param key Property key.127 // /// @param value Propery value.128 // /// @dev EVM selector for this function is: 0x2f073f66,129 // /// or in textual repr: setCollectionProperty(string,bytes)130 // function setCollectionProperty(string memory key, bytes memory value) public {131 // require(false, stub_error);132 // key;133 // value;134 // dummy = 0;135 // }136137 /// Set collection properties.138 ///139 /// @param properties Vector of properties key/value pair.140 /// @dev EVM selector for this function is: 0x50b26b2a,141 /// or in textual repr: setCollectionProperties((string,bytes)[])142 function setCollectionProperties(Property[] memory properties) public {143 require(false, stub_error);144 properties;145 dummy = 0;146 }147148 // /// Delete collection property.149 // ///150 // /// @param key Property key.151 // /// @dev EVM selector for this function is: 0x7b7debce,152 // /// or in textual repr: deleteCollectionProperty(string)153 // function deleteCollectionProperty(string memory key) public {154 // require(false, stub_error);155 // key;156 // dummy = 0;157 // }158159 /// Delete collection properties.160 ///161 /// @param keys Properties keys.162 /// @dev EVM selector for this function is: 0xee206ee3,163 /// or in textual repr: deleteCollectionProperties(string[])164 function deleteCollectionProperties(string[] memory keys) public {165 require(false, stub_error);166 keys;167 dummy = 0;168 }169170 /// Get collection property.171 ///172 /// @dev Throws error if key not found.173 ///174 /// @param key Property key.175 /// @return bytes The property corresponding to the key.176 /// @dev EVM selector for this function is: 0xcf24fd6d,177 /// or in textual repr: collectionProperty(string)178 function collectionProperty(string memory key) public view returns (bytes memory) {179 require(false, stub_error);180 key;181 dummy;182 return hex"";183 }184185 /// Get collection properties.186 ///187 /// @param keys Properties keys. Empty keys for all propertyes.188 /// @return Vector of properties key/value pairs.189 /// @dev EVM selector for this function is: 0x285fb8e6,190 /// or in textual repr: collectionProperties(string[])191 function collectionProperties(string[] memory keys) public view returns (Tuple23[] memory) {192 require(false, stub_error);193 keys;194 dummy;195 return new Tuple23[](0);196 }197198 // /// Set the sponsor of the collection.199 // ///200 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201 // ///202 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203 // /// @dev EVM selector for this function is: 0x7623402e,204 // /// or in textual repr: setCollectionSponsor(address)205 // function setCollectionSponsor(address sponsor) public {206 // require(false, stub_error);207 // sponsor;208 // dummy = 0;209 // }210211 /// Set the sponsor of the collection.212 ///213 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214 ///215 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216 /// @dev EVM selector for this function is: 0x84a1d5a8,217 /// or in textual repr: setCollectionSponsorCross((address,uint256))218 function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219 require(false, stub_error);220 sponsor;221 dummy = 0;222 }223224 /// Whether there is a pending sponsor.225 /// @dev EVM selector for this function is: 0x058ac185,226 /// or in textual repr: hasCollectionPendingSponsor()227 function hasCollectionPendingSponsor() public view returns (bool) {228 require(false, stub_error);229 dummy;230 return false;231 }232233 /// Collection sponsorship confirmation.234 ///235 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.236 /// @dev EVM selector for this function is: 0x3c50e97a,237 /// or in textual repr: confirmCollectionSponsorship()238 function confirmCollectionSponsorship() public {239 require(false, stub_error);240 dummy = 0;241 }242243 /// Remove collection sponsor.244 /// @dev EVM selector for this function is: 0x6e0326a3,245 /// or in textual repr: removeCollectionSponsor()246 function removeCollectionSponsor() public {247 require(false, stub_error);248 dummy = 0;249 }250251 /// Get current sponsor.252 ///253 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254 /// @dev EVM selector for this function is: 0x6ec0a9f1,255 /// or in textual repr: collectionSponsor()256 function collectionSponsor() public view returns (Tuple26 memory) {257 require(false, stub_error);258 dummy;259 return Tuple26(0x0000000000000000000000000000000000000000, 0);260 }261262 /// Set limits for the collection.263 /// @dev Throws error if limit not found.264 /// @param limit Name of the limit. Valid names:265 /// "accountTokenOwnershipLimit",266 /// "sponsoredDataSize",267 /// "sponsoredDataRateLimit",268 /// "tokenLimit",269 /// "sponsorTransferTimeout",270 /// "sponsorApproveTimeout"271 /// @param value Value of the limit.272 /// @dev EVM selector for this function is: 0x6a3841db,273 /// or in textual repr: setCollectionLimit(string,uint32)274 function setCollectionLimit(string memory limit, uint32 value) public {275 require(false, stub_error);276 limit;277 value;278 dummy = 0;279 }280281 /// Set limits for the collection.282 /// @dev Throws error if limit not found.283 /// @param limit Name of the limit. Valid names:284 /// "ownerCanTransfer",285 /// "ownerCanDestroy",286 /// "transfersEnabled"287 /// @param value Value of the limit.288 /// @dev EVM selector for this function is: 0x993b7fba,289 /// or in textual repr: setCollectionLimit(string,bool)290 function setCollectionLimit(string memory limit, bool value) public {291 require(false, stub_error);292 limit;293 value;294 dummy = 0;295 }296297 /// Get contract address.298 /// @dev EVM selector for this function is: 0xf6b4dfb4,299 /// or in textual repr: contractAddress()300 function contractAddress() public view returns (address) {301 require(false, stub_error);302 dummy;303 return 0x0000000000000000000000000000000000000000;304 }305306 /// Add collection admin.307 /// @param newAdmin Cross account administrator address.308 /// @dev EVM selector for this function is: 0x859aa7d6,309 /// or in textual repr: addCollectionAdminCross((address,uint256))310 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {311 require(false, stub_error);312 newAdmin;313 dummy = 0;314 }315316 /// Remove collection admin.317 /// @param admin Cross account administrator address.318 /// @dev EVM selector for this function is: 0x6c0cd173,319 /// or in textual repr: removeCollectionAdminCross((address,uint256))320 function removeCollectionAdminCross(EthCrossAccount memory admin) public {321 require(false, stub_error);322 admin;323 dummy = 0;324 }325326 // /// Add collection admin.327 // /// @param newAdmin Address of the added administrator.328 // /// @dev EVM selector for this function is: 0x92e462c7,329 // /// or in textual repr: addCollectionAdmin(address)330 // function addCollectionAdmin(address newAdmin) public {331 // require(false, stub_error);332 // newAdmin;333 // dummy = 0;334 // }335336 // /// Remove collection admin.337 // ///338 // /// @param admin Address of the removed administrator.339 // /// @dev EVM selector for this function is: 0xfafd7b42,340 // /// or in textual repr: removeCollectionAdmin(address)341 // function removeCollectionAdmin(address admin) public {342 // require(false, stub_error);343 // admin;344 // dummy = 0;345 // }346347 /// Toggle accessibility of collection nesting.348 ///349 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'350 /// @dev EVM selector for this function is: 0x112d4586,351 /// or in textual repr: setCollectionNesting(bool)352 function setCollectionNesting(bool enable) public {353 require(false, stub_error);354 enable;355 dummy = 0;356 }357358 /// Toggle accessibility of collection nesting.359 ///360 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'361 /// @param collections Addresses of collections that will be available for nesting.362 /// @dev EVM selector for this function is: 0x64872396,363 /// or in textual repr: setCollectionNesting(bool,address[])364 function setCollectionNesting(bool enable, address[] memory collections) public {365 require(false, stub_error);366 enable;367 collections;368 dummy = 0;369 }370371 /// Set the collection access method.372 /// @param mode Access mode373 /// 0 for Normal374 /// 1 for AllowList375 /// @dev EVM selector for this function is: 0x41835d4c,376 /// or in textual repr: setCollectionAccess(uint8)377 function setCollectionAccess(uint8 mode) public {378 require(false, stub_error);379 mode;380 dummy = 0;381 }382383 /// Checks that user allowed to operate with collection.384 ///385 /// @param user User address to check.386 /// @dev EVM selector for this function is: 0xd63a8e11,387 /// or in textual repr: allowed(address)388 function allowed(address user) public view returns (bool) {389 require(false, stub_error);390 user;391 dummy;392 return false;393 }394395 // /// Add the user to the allowed list.396 // ///397 // /// @param user Address of a trusted user.398 // /// @dev EVM selector for this function is: 0x67844fe6,399 // /// or in textual repr: addToCollectionAllowList(address)400 // function addToCollectionAllowList(address user) public {401 // require(false, stub_error);402 // user;403 // dummy = 0;404 // }405406 /// Add user to allowed list.407 ///408 /// @param user User cross account address.409 /// @dev EVM selector for this function is: 0xa0184a3a,410 /// or in textual repr: addToCollectionAllowListCross((address,uint256))411 function addToCollectionAllowListCross(EthCrossAccount memory user) public {412 require(false, stub_error);413 user;414 dummy = 0;415 }416417 // /// Remove the user from the allowed list.418 // ///419 // /// @param user Address of a removed user.420 // /// @dev EVM selector for this function is: 0x85c51acb,421 // /// or in textual repr: removeFromCollectionAllowList(address)422 // function removeFromCollectionAllowList(address user) public {423 // require(false, stub_error);424 // user;425 // dummy = 0;426 // }427428 /// Remove user from allowed list.429 ///430 /// @param user User cross account address.431 /// @dev EVM selector for this function is: 0x09ba452a,432 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))433 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {434 require(false, stub_error);435 user;436 dummy = 0;437 }438439 /// Switch permission for minting.440 ///441 /// @param mode Enable if "true".442 /// @dev EVM selector for this function is: 0x00018e84,443 /// or in textual repr: setCollectionMintMode(bool)444 function setCollectionMintMode(bool mode) public {445 require(false, stub_error);446 mode;447 dummy = 0;448 }449450 // /// Check that account is the owner or admin of the collection451 // ///452 // /// @param user account to verify453 // /// @return "true" if account is the owner or admin454 // /// @dev EVM selector for this function is: 0x9811b0c7,455 // /// or in textual repr: isOwnerOrAdmin(address)456 // function isOwnerOrAdmin(address user) public view returns (bool) {457 // require(false, stub_error);458 // user;459 // dummy;460 // return false;461 // }462463 /// Check that account is the owner or admin of the collection464 ///465 /// @param user User cross account to verify466 /// @return "true" if account is the owner or admin467 /// @dev EVM selector for this function is: 0x3e75a905,468 /// or in textual repr: isOwnerOrAdminCross((address,uint256))469 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {470 require(false, stub_error);471 user;472 dummy;473 return false;474 }475476 /// Returns collection type477 ///478 /// @return `Fungible` or `NFT` or `ReFungible`479 /// @dev EVM selector for this function is: 0xd34b55b8,480 /// or in textual repr: uniqueCollectionType()481 function uniqueCollectionType() public view returns (string memory) {482 require(false, stub_error);483 dummy;484 return "";485 }486487 /// Get collection owner.488 ///489 /// @return Tuble with sponsor address and his substrate mirror.490 /// If address is canonical then substrate mirror is zero and vice versa.491 /// @dev EVM selector for this function is: 0xdf727d3b,492 /// or in textual repr: collectionOwner()493 function collectionOwner() public view returns (EthCrossAccount memory) {494 require(false, stub_error);495 dummy;496 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);497 }498499 // /// Changes collection owner to another account500 // ///501 // /// @dev Owner can be changed only by current owner502 // /// @param newOwner new owner account503 // /// @dev EVM selector for this function is: 0x4f53e226,504 // /// or in textual repr: changeCollectionOwner(address)505 // function changeCollectionOwner(address newOwner) public {506 // require(false, stub_error);507 // newOwner;508 // dummy = 0;509 // }510511 /// Get collection administrators512 ///513 /// @return Vector of tuples with admins address and his substrate mirror.514 /// If address is canonical then substrate mirror is zero and vice versa.515 /// @dev EVM selector for this function is: 0x5813216b,516 /// or in textual repr: collectionAdmins()517 function collectionAdmins() public view returns (EthCrossAccount[] memory) {518 require(false, stub_error);519 dummy;520 return new EthCrossAccount[](0);521 }522523 /// Changes collection owner to another account524 ///525 /// @dev Owner can be changed only by current owner526 /// @param newOwner new owner cross account527 /// @dev EVM selector for this function is: 0x6496c497,528 /// or in textual repr: changeCollectionOwnerCross((address,uint256))529 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {530 require(false, stub_error);531 newOwner;532 dummy = 0;533 }534}535536/// @dev Cross account struct537struct EthCrossAccount {538 address eth;539 uint256 sub;540}541542/// @dev anonymous struct543struct Tuple26 {544 address field_0;545 uint256 field_1;546}547548/// @dev anonymous struct549struct Tuple23 {550 string field_0;551 bytes field_1;552}553554/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension555/// @dev See https://eips.ethereum.org/EIPS/eip-721556/// @dev the ERC-165 identifier for this interface is 0x5b5e139f557contract ERC721Metadata is Dummy, ERC165 {558 // /// @notice A descriptive name for a collection of NFTs in this contract559 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`560 // /// @dev EVM selector for this function is: 0x06fdde03,561 // /// or in textual repr: name()562 // function name() public view returns (string memory) {563 // require(false, stub_error);564 // dummy;565 // return "";566 // }567568 // /// @notice An abbreviated name for NFTs in this contract569 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`570 // /// @dev EVM selector for this function is: 0x95d89b41,571 // /// or in textual repr: symbol()572 // function symbol() public view returns (string memory) {573 // require(false, stub_error);574 // dummy;575 // return "";576 // }577578 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.579 ///580 /// @dev If the token has a `url` property and it is not empty, it is returned.581 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.582 /// If the collection property `baseURI` is empty or absent, return "" (empty string)583 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix584 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).585 ///586 /// @return token's const_metadata587 /// @dev EVM selector for this function is: 0xc87b56dd,588 /// or in textual repr: tokenURI(uint256)589 function tokenURI(uint256 tokenId) public view returns (string memory) {590 require(false, stub_error);591 tokenId;592 dummy;593 return "";594 }595}596597/// @title ERC721 Token that can be irreversibly burned (destroyed).598/// @dev the ERC-165 identifier for this interface is 0x42966c68599contract ERC721Burnable is Dummy, ERC165 {600 /// @notice Burns a specific ERC721 token.601 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized602 /// operator of the current owner.603 /// @param tokenId The NFT to approve604 /// @dev EVM selector for this function is: 0x42966c68,605 /// or in textual repr: burn(uint256)606 function burn(uint256 tokenId) public {607 require(false, stub_error);608 tokenId;609 dummy = 0;610 }611}612613/// @dev inlined interface614contract ERC721UniqueMintableEvents {615 event MintingFinished();616}617618/// @title ERC721 minting logic.619/// @dev the ERC-165 identifier for this interface is 0x476ff149620contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {621 /// @dev EVM selector for this function is: 0x05d2035b,622 /// or in textual repr: mintingFinished()623 function mintingFinished() public view returns (bool) {624 require(false, stub_error);625 dummy;626 return false;627 }628629 /// @notice Function to mint token.630 /// @param to The new owner631 /// @return uint256 The id of the newly minted token632 /// @dev EVM selector for this function is: 0x6a627842,633 /// or in textual repr: mint(address)634 function mint(address to) public returns (uint256) {635 require(false, stub_error);636 to;637 dummy = 0;638 return 0;639 }640641 // /// @notice Function to mint token.642 // /// @dev `tokenId` should be obtained with `nextTokenId` method,643 // /// unlike standard, you can't specify it manually644 // /// @param to The new owner645 // /// @param tokenId ID of the minted NFT646 // /// @dev EVM selector for this function is: 0x40c10f19,647 // /// or in textual repr: mint(address,uint256)648 // function mint(address to, uint256 tokenId) public returns (bool) {649 // require(false, stub_error);650 // to;651 // tokenId;652 // dummy = 0;653 // return false;654 // }655656 /// @notice Function to mint token with the given tokenUri.657 /// @param to The new owner658 /// @param tokenUri Token URI that would be stored in the NFT properties659 /// @return uint256 The id of the newly minted token660 /// @dev EVM selector for this function is: 0x45c17782,661 /// or in textual repr: mintWithTokenURI(address,string)662 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {663 require(false, stub_error);664 to;665 tokenUri;666 dummy = 0;667 return 0;668 }669670 // /// @notice Function to mint token with the given tokenUri.671 // /// @dev `tokenId` should be obtained with `nextTokenId` method,672 // /// unlike standard, you can't specify it manually673 // /// @param to The new owner674 // /// @param tokenId ID of the minted NFT675 // /// @param tokenUri Token URI that would be stored in the NFT properties676 // /// @dev EVM selector for this function is: 0x50bb4e7f,677 // /// or in textual repr: mintWithTokenURI(address,uint256,string)678 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {679 // require(false, stub_error);680 // to;681 // tokenId;682 // tokenUri;683 // dummy = 0;684 // return false;685 // }686687 /// @dev Not implemented688 /// @dev EVM selector for this function is: 0x7d64bcb4,689 /// or in textual repr: finishMinting()690 function finishMinting() public returns (bool) {691 require(false, stub_error);692 dummy = 0;693 return false;694 }695}696697/// @title Unique extensions for ERC721.698/// @dev the ERC-165 identifier for this interface is 0x0e9fc611699contract ERC721UniqueExtensions is Dummy, ERC165 {700 /// @notice A descriptive name for a collection of NFTs in this contract701 /// @dev EVM selector for this function is: 0x06fdde03,702 /// or in textual repr: name()703 function name() public view returns (string memory) {704 require(false, stub_error);705 dummy;706 return "";707 }708709 /// @notice An abbreviated name for NFTs in this contract710 /// @dev EVM selector for this function is: 0x95d89b41,711 /// or in textual repr: symbol()712 function symbol() public view returns (string memory) {713 require(false, stub_error);714 dummy;715 return "";716 }717718 /// @notice Set or reaffirm the approved address for an NFT719 /// @dev The zero address indicates there is no approved address.720 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized721 /// operator of the current owner.722 /// @param approved The new substrate address approved NFT controller723 /// @param tokenId The NFT to approve724 /// @dev EVM selector for this function is: 0x0ecd0ab0,725 /// or in textual repr: approveCross((address,uint256),uint256)726 function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {727 require(false, stub_error);728 approved;729 tokenId;730 dummy = 0;731 }732733 /// @notice Transfer ownership of an NFT734 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`735 /// is the zero address. Throws if `tokenId` is not a valid NFT.736 /// @param to The new owner737 /// @param tokenId The NFT to transfer738 /// @dev EVM selector for this function is: 0xa9059cbb,739 /// or in textual repr: transfer(address,uint256)740 function transfer(address to, uint256 tokenId) public {741 require(false, stub_error);742 to;743 tokenId;744 dummy = 0;745 }746747 /// @notice Transfer ownership of an NFT748 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`749 /// is the zero address. Throws if `tokenId` is not a valid NFT.750 /// @param to The new owner751 /// @param tokenId The NFT to transfer752 /// @dev EVM selector for this function is: 0x2ada85ff,753 /// or in textual repr: transferCross((address,uint256),uint256)754 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {755 require(false, stub_error);756 to;757 tokenId;758 dummy = 0;759 }760761 /// @notice Transfer ownership of an NFT from cross account address to cross account address762 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`763 /// is the zero address. Throws if `tokenId` is not a valid NFT.764 /// @param from Cross acccount address of current owner765 /// @param to Cross acccount address of new owner766 /// @param tokenId The NFT to transfer767 /// @dev EVM selector for this function is: 0xd5cf430b,768 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)769 function transferFromCross(770 EthCrossAccount memory from,771 EthCrossAccount memory to,772 uint256 tokenId773 ) public {774 require(false, stub_error);775 from;776 to;777 tokenId;778 dummy = 0;779 }780781 // /// @notice Burns a specific ERC721 token.782 // /// @dev Throws unless `msg.sender` is the current owner or an authorized783 // /// operator for this NFT. Throws if `from` is not the current owner. Throws784 // /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.785 // /// @param from The current owner of the NFT786 // /// @param tokenId The NFT to transfer787 // /// @dev EVM selector for this function is: 0x79cc6790,788 // /// or in textual repr: burnFrom(address,uint256)789 // function burnFrom(address from, uint256 tokenId) public {790 // require(false, stub_error);791 // from;792 // tokenId;793 // dummy = 0;794 // }795796 /// @notice Burns a specific ERC721 token.797 /// @dev Throws unless `msg.sender` is the current owner or an authorized798 /// operator for this NFT. Throws if `from` is not the current owner. Throws799 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.800 /// @param from The current owner of the NFT801 /// @param tokenId The NFT to transfer802 /// @dev EVM selector for this function is: 0xbb2f5a58,803 /// or in textual repr: burnFromCross((address,uint256),uint256)804 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {805 require(false, stub_error);806 from;807 tokenId;808 dummy = 0;809 }810811 /// @notice Returns next free NFT ID.812 /// @dev EVM selector for this function is: 0x75794a3c,813 /// or in textual repr: nextTokenId()814 function nextTokenId() public view returns (uint256) {815 require(false, stub_error);816 dummy;817 return 0;818 }819 // /// @notice Function to mint multiple tokens.820 // /// @dev `tokenIds` should be an array of consecutive numbers and first number821 // /// should be obtained with `nextTokenId` method822 // /// @param to The new owner823 // /// @param tokenIds IDs of the minted NFTs824 // /// @dev EVM selector for this function is: 0x44a9945e,825 // /// or in textual repr: mintBulk(address,uint256[])826 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {827 // require(false, stub_error);828 // to;829 // tokenIds;830 // dummy = 0;831 // return false;832 // }833834 // /// @notice Function to mint multiple tokens with the given tokenUris.835 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive836 // /// numbers and first number should be obtained with `nextTokenId` method837 // /// @param to The new owner838 // /// @param tokens array of pairs of token ID and token URI for minted tokens839 // /// @dev EVM selector for this function is: 0x36543006,840 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])841 // function mintBulkWithTokenURI(address to, Tuple11[] memory tokens) public returns (bool) {842 // require(false, stub_error);843 // to;844 // tokens;845 // dummy = 0;846 // return false;847 // }848849}850851/// @dev anonymous struct852struct Tuple11 {853 uint256 field_0;854 string field_1;855}856857/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension858/// @dev See https://eips.ethereum.org/EIPS/eip-721859/// @dev the ERC-165 identifier for this interface is 0x780e9d63860contract ERC721Enumerable is Dummy, ERC165 {861 /// @notice Enumerate valid NFTs862 /// @param index A counter less than `totalSupply()`863 /// @return The token identifier for the `index`th NFT,864 /// (sort order not specified)865 /// @dev EVM selector for this function is: 0x4f6ccce7,866 /// or in textual repr: tokenByIndex(uint256)867 function tokenByIndex(uint256 index) public view returns (uint256) {868 require(false, stub_error);869 index;870 dummy;871 return 0;872 }873874 /// @dev Not implemented875 /// @dev EVM selector for this function is: 0x2f745c59,876 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)877 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {878 require(false, stub_error);879 owner;880 index;881 dummy;882 return 0;883 }884885 /// @notice Count NFTs tracked by this contract886 /// @return A count of valid NFTs tracked by this contract, where each one of887 /// them has an assigned and queryable owner not equal to the zero address888 /// @dev EVM selector for this function is: 0x18160ddd,889 /// or in textual repr: totalSupply()890 function totalSupply() public view returns (uint256) {891 require(false, stub_error);892 dummy;893 return 0;894 }895}896897/// @dev inlined interface898contract ERC721Events {899 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);900 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);901 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);902}903904/// @title ERC-721 Non-Fungible Token Standard905/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md906/// @dev the ERC-165 identifier for this interface is 0x80ac58cd907contract ERC721 is Dummy, ERC165, ERC721Events {908 /// @notice Count all NFTs assigned to an owner909 /// @dev NFTs assigned to the zero address are considered invalid, and this910 /// function throws for queries about the zero address.911 /// @param owner An address for whom to query the balance912 /// @return The number of NFTs owned by `owner`, possibly zero913 /// @dev EVM selector for this function is: 0x70a08231,914 /// or in textual repr: balanceOf(address)915 function balanceOf(address owner) public view returns (uint256) {916 require(false, stub_error);917 owner;918 dummy;919 return 0;920 }921922 /// @notice Find the owner of an NFT923 /// @dev NFTs assigned to zero address are considered invalid, and queries924 /// about them do throw.925 /// @param tokenId The identifier for an NFT926 /// @return The address of the owner of the NFT927 /// @dev EVM selector for this function is: 0x6352211e,928 /// or in textual repr: ownerOf(uint256)929 function ownerOf(uint256 tokenId) public view returns (address) {930 require(false, stub_error);931 tokenId;932 dummy;933 return 0x0000000000000000000000000000000000000000;934 }935936 /// @dev Not implemented937 /// @dev EVM selector for this function is: 0xb88d4fde,938 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)939 function safeTransferFrom(940 address from,941 address to,942 uint256 tokenId,943 bytes memory data944 ) public {945 require(false, stub_error);946 from;947 to;948 tokenId;949 data;950 dummy = 0;951 }952953 /// @dev Not implemented954 /// @dev EVM selector for this function is: 0x42842e0e,955 /// or in textual repr: safeTransferFrom(address,address,uint256)956 function safeTransferFrom(957 address from,958 address to,959 uint256 tokenId960 ) public {961 require(false, stub_error);962 from;963 to;964 tokenId;965 dummy = 0;966 }967968 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE969 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE970 /// THEY MAY BE PERMANENTLY LOST971 /// @dev Throws unless `msg.sender` is the current owner or an authorized972 /// operator for this NFT. Throws if `from` is not the current owner. Throws973 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.974 /// @param from The current owner of the NFT975 /// @param to The new owner976 /// @param tokenId The NFT to transfer977 /// @dev EVM selector for this function is: 0x23b872dd,978 /// or in textual repr: transferFrom(address,address,uint256)979 function transferFrom(980 address from,981 address to,982 uint256 tokenId983 ) public {984 require(false, stub_error);985 from;986 to;987 tokenId;988 dummy = 0;989 }990991 /// @notice Set or reaffirm the approved address for an NFT992 /// @dev The zero address indicates there is no approved address.993 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized994 /// operator of the current owner.995 /// @param approved The new approved NFT controller996 /// @param tokenId The NFT to approve997 /// @dev EVM selector for this function is: 0x095ea7b3,998 /// or in textual repr: approve(address,uint256)999 function approve(address approved, uint256 tokenId) public {1000 require(false, stub_error);1001 approved;1002 tokenId;1003 dummy = 0;1004 }10051006 /// @dev Not implemented1007 /// @dev EVM selector for this function is: 0xa22cb465,1008 /// or in textual repr: setApprovalForAll(address,bool)1009 function setApprovalForAll(address operator, bool approved) public {1010 require(false, stub_error);1011 operator;1012 approved;1013 dummy = 0;1014 }10151016 /// @dev Not implemented1017 /// @dev EVM selector for this function is: 0x081812fc,1018 /// or in textual repr: getApproved(uint256)1019 function getApproved(uint256 tokenId) public view returns (address) {1020 require(false, stub_error);1021 tokenId;1022 dummy;1023 return 0x0000000000000000000000000000000000000000;1024 }10251026 /// @dev Not implemented1027 /// @dev EVM selector for this function is: 0xe985e9c5,1028 /// or in textual repr: isApprovedForAll(address,address)1029 function isApprovedForAll(address owner, address operator) public view returns (address) {1030 require(false, stub_error);1031 owner;1032 operator;1033 dummy;1034 return 0x0000000000000000000000000000000000000000;1035 }1036}10371038contract UniqueNFT is1039 Dummy,1040 ERC165,1041 ERC721,1042 ERC721Enumerable,1043 ERC721UniqueExtensions,1044 ERC721UniqueMintable,1045 ERC721Burnable,1046 ERC721Metadata,1047 Collection,1048 TokenProperties1049{}