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 0xde0695c222contract 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(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {32 // require(false, stub_error);33 // key;34 // isMutable;35 // collectionAdmin;36 // tokenOwner;37 // dummy = 0;38 // }3940 /// @notice Set permissions for token property.41 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.42 /// @param permissions Permissions for keys.43 /// @dev EVM selector for this function is: 0xbd92983a,44 /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])45 function setTokenPropertyPermissions(Tuple48[] memory permissions) public {46 require(false, stub_error);47 permissions;48 dummy = 0;49 }5051 /// @dev EVM selector for this function is: 0xf23d7790,52 /// or in textual repr: tokenPropertyPermissions()53 function tokenPropertyPermissions() public view returns (Tuple48[] memory) {54 require(false, stub_error);55 dummy;56 return new Tuple48[](0);57 }5859 // /// @notice Set token property value.60 // /// @dev Throws error if `msg.sender` has no permission to edit the property.61 // /// @param tokenId ID of the token.62 // /// @param key Property key.63 // /// @param value Property value.64 // /// @dev EVM selector for this function is: 0x1752d67b,65 // /// or in textual repr: setProperty(uint256,string,bytes)66 // function setProperty(uint256 tokenId, string memory key, bytes memory value) public {67 // require(false, stub_error);68 // tokenId;69 // key;70 // value;71 // dummy = 0;72 // }7374 /// @notice Set token properties value.75 /// @dev Throws error if `msg.sender` has no permission to edit the property.76 /// @param tokenId ID of the token.77 /// @param properties settable properties78 /// @dev EVM selector for this function is: 0x14ed3a6e,79 /// or in textual repr: setProperties(uint256,(string,bytes)[])80 function setProperties(uint256 tokenId, Property[] memory properties) public {81 require(false, stub_error);82 tokenId;83 properties;84 dummy = 0;85 }8687 // /// @notice Delete token property value.88 // /// @dev Throws error if `msg.sender` has no permission to edit the property.89 // /// @param tokenId ID of the token.90 // /// @param key Property key.91 // /// @dev EVM selector for this function is: 0x066111d1,92 // /// or in textual repr: deleteProperty(uint256,string)93 // function deleteProperty(uint256 tokenId, string memory key) public {94 // require(false, stub_error);95 // tokenId;96 // key;97 // dummy = 0;98 // }99100 /// @notice Delete token properties value.101 /// @dev Throws error if `msg.sender` has no permission to edit the property.102 /// @param tokenId ID of the token.103 /// @param keys Properties key.104 /// @dev EVM selector for this function is: 0xc472d371,105 /// or in textual repr: deleteProperties(uint256,string[])106 function deleteProperties(uint256 tokenId, string[] memory keys) public {107 require(false, stub_error);108 tokenId;109 keys;110 dummy = 0;111 }112113 /// @notice Get token property value.114 /// @dev Throws error if key not found115 /// @param tokenId ID of the token.116 /// @param key Property key.117 /// @return Property value bytes118 /// @dev EVM selector for this function is: 0x7228c327,119 /// or in textual repr: property(uint256,string)120 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {121 require(false, stub_error);122 tokenId;123 key;124 dummy;125 return hex"";126 }127}128129/// @dev Property struct130struct Property {131 string key;132 bytes value;133}134135enum EthTokenPermissions {136 Mutable,137 TokenOwner,138 CollectionAdmin139}140141/// @dev anonymous struct142struct Tuple48 {143 string field_0;144 Tuple46[] field_1;145}146147/// @dev anonymous struct148struct Tuple46 {149 EthTokenPermissions field_0;150 bool field_1;151}152153/// @title A contract that allows you to work with collections.154/// @dev the ERC-165 identifier for this interface is 0xb5e1747f155contract Collection is Dummy, ERC165 {156 // /// Set collection property.157 // ///158 // /// @param key Property key.159 // /// @param value Propery value.160 // /// @dev EVM selector for this function is: 0x2f073f66,161 // /// or in textual repr: setCollectionProperty(string,bytes)162 // function setCollectionProperty(string memory key, bytes memory value) public {163 // require(false, stub_error);164 // key;165 // value;166 // dummy = 0;167 // }168169 /// Set collection properties.170 ///171 /// @param properties Vector of properties key/value pair.172 /// @dev EVM selector for this function is: 0x50b26b2a,173 /// or in textual repr: setCollectionProperties((string,bytes)[])174 function setCollectionProperties(Property[] memory properties) public {175 require(false, stub_error);176 properties;177 dummy = 0;178 }179180 // /// Delete collection property.181 // ///182 // /// @param key Property key.183 // /// @dev EVM selector for this function is: 0x7b7debce,184 // /// or in textual repr: deleteCollectionProperty(string)185 // function deleteCollectionProperty(string memory key) public {186 // require(false, stub_error);187 // key;188 // dummy = 0;189 // }190191 /// Delete collection properties.192 ///193 /// @param keys Properties keys.194 /// @dev EVM selector for this function is: 0xee206ee3,195 /// or in textual repr: deleteCollectionProperties(string[])196 function deleteCollectionProperties(string[] memory keys) public {197 require(false, stub_error);198 keys;199 dummy = 0;200 }201202 /// Get collection property.203 ///204 /// @dev Throws error if key not found.205 ///206 /// @param key Property key.207 /// @return bytes The property corresponding to the key.208 /// @dev EVM selector for this function is: 0xcf24fd6d,209 /// or in textual repr: collectionProperty(string)210 function collectionProperty(string memory key) public view returns (bytes memory) {211 require(false, stub_error);212 key;213 dummy;214 return hex"";215 }216217 /// Get collection properties.218 ///219 /// @param keys Properties keys. Empty keys for all propertyes.220 /// @return Vector of properties key/value pairs.221 /// @dev EVM selector for this function is: 0x285fb8e6,222 /// or in textual repr: collectionProperties(string[])223 function collectionProperties(string[] memory keys) public view returns (Property[] memory) {224 require(false, stub_error);225 keys;226 dummy;227 return new Property[](0);228 }229230 // /// Set the sponsor of the collection.231 // ///232 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.233 // ///234 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.235 // /// @dev EVM selector for this function is: 0x7623402e,236 // /// or in textual repr: setCollectionSponsor(address)237 // function setCollectionSponsor(address sponsor) public {238 // require(false, stub_error);239 // sponsor;240 // dummy = 0;241 // }242243 /// Set the sponsor of the collection.244 ///245 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.246 ///247 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.248 /// @dev EVM selector for this function is: 0x84a1d5a8,249 /// or in textual repr: setCollectionSponsorCross((address,uint256))250 function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {251 require(false, stub_error);252 sponsor;253 dummy = 0;254 }255256 /// Whether there is a pending sponsor.257 /// @dev EVM selector for this function is: 0x058ac185,258 /// or in textual repr: hasCollectionPendingSponsor()259 function hasCollectionPendingSponsor() public view returns (bool) {260 require(false, stub_error);261 dummy;262 return false;263 }264265 /// Collection sponsorship confirmation.266 ///267 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.268 /// @dev EVM selector for this function is: 0x3c50e97a,269 /// or in textual repr: confirmCollectionSponsorship()270 function confirmCollectionSponsorship() public {271 require(false, stub_error);272 dummy = 0;273 }274275 /// Remove collection sponsor.276 /// @dev EVM selector for this function is: 0x6e0326a3,277 /// or in textual repr: removeCollectionSponsor()278 function removeCollectionSponsor() public {279 require(false, stub_error);280 dummy = 0;281 }282283 /// Get current sponsor.284 ///285 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.286 /// @dev EVM selector for this function is: 0x6ec0a9f1,287 /// or in textual repr: collectionSponsor()288 function collectionSponsor() public view returns (Tuple30 memory) {289 require(false, stub_error);290 dummy;291 return Tuple30(0x0000000000000000000000000000000000000000, 0);292 }293294 /// Get current collection limits.295 ///296 /// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:297 /// "accountTokenOwnershipLimit",298 /// "sponsoredDataSize",299 /// "sponsoredDataRateLimit",300 /// "tokenLimit",301 /// "sponsorTransferTimeout",302 /// "sponsorApproveTimeout"303 /// "ownerCanTransfer",304 /// "ownerCanDestroy",305 /// "transfersEnabled"306 /// Return `false` if a limit not set.307 /// @dev EVM selector for this function is: 0xf63bc572,308 /// or in textual repr: collectionLimits()309 function collectionLimits() public view returns (Tuple33[] memory) {310 require(false, stub_error);311 dummy;312 return new Tuple33[](0);313 }314315 /// Set limits for the collection.316 /// @dev Throws error if limit not found.317 /// @param limit Name of the limit. Valid names:318 /// "accountTokenOwnershipLimit",319 /// "sponsoredDataSize",320 /// "sponsoredDataRateLimit",321 /// "tokenLimit",322 /// "sponsorTransferTimeout",323 /// "sponsorApproveTimeout"324 /// "ownerCanTransfer",325 /// "ownerCanDestroy",326 /// "transfersEnabled"327 /// @param value Value of the limit.328 /// @dev EVM selector for this function is: 0x88150bd0,329 /// or in textual repr: setCollectionLimit(uint8,bool,uint256)330 function setCollectionLimit(331 CollectionLimits limit,332 bool status,333 uint256 value334 ) public {335 require(false, stub_error);336 limit;337 status;338 value;339 dummy = 0;340 }341342 /// Get contract address.343 /// @dev EVM selector for this function is: 0xf6b4dfb4,344 /// or in textual repr: contractAddress()345 function contractAddress() public view returns (address) {346 require(false, stub_error);347 dummy;348 return 0x0000000000000000000000000000000000000000;349 }350351 /// Add collection admin.352 /// @param newAdmin Cross account administrator address.353 /// @dev EVM selector for this function is: 0x859aa7d6,354 /// or in textual repr: addCollectionAdminCross((address,uint256))355 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {356 require(false, stub_error);357 newAdmin;358 dummy = 0;359 }360361 /// Remove collection admin.362 /// @param admin Cross account administrator address.363 /// @dev EVM selector for this function is: 0x6c0cd173,364 /// or in textual repr: removeCollectionAdminCross((address,uint256))365 function removeCollectionAdminCross(EthCrossAccount memory admin) public {366 require(false, stub_error);367 admin;368 dummy = 0;369 }370371 // /// Add collection admin.372 // /// @param newAdmin Address of the added administrator.373 // /// @dev EVM selector for this function is: 0x92e462c7,374 // /// or in textual repr: addCollectionAdmin(address)375 // function addCollectionAdmin(address newAdmin) public {376 // require(false, stub_error);377 // newAdmin;378 // dummy = 0;379 // }380381 // /// Remove collection admin.382 // ///383 // /// @param admin Address of the removed administrator.384 // /// @dev EVM selector for this function is: 0xfafd7b42,385 // /// or in textual repr: removeCollectionAdmin(address)386 // function removeCollectionAdmin(address admin) public {387 // require(false, stub_error);388 // admin;389 // dummy = 0;390 // }391392 /// Toggle accessibility of collection nesting.393 ///394 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'395 /// @dev EVM selector for this function is: 0x112d4586,396 /// or in textual repr: setCollectionNesting(bool)397 function setCollectionNesting(bool enable) public {398 require(false, stub_error);399 enable;400 dummy = 0;401 }402403 /// Toggle accessibility of collection nesting.404 ///405 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'406 /// @param collections Addresses of collections that will be available for nesting.407 /// @dev EVM selector for this function is: 0x64872396,408 /// or in textual repr: setCollectionNesting(bool,address[])409 function setCollectionNesting(bool enable, address[] memory collections) public {410 require(false, stub_error);411 enable;412 collections;413 dummy = 0;414 }415416 /// Returns nesting for a collection417 /// @dev EVM selector for this function is: 0x22d25bfe,418 /// or in textual repr: collectionNestingRestrictedCollectionIds()419 function collectionNestingRestrictedCollectionIds() public view returns (Tuple34 memory) {420 require(false, stub_error);421 dummy;422 return Tuple34(false, new uint256[](0));423 }424425 /// Returns permissions for a collection426 /// @dev EVM selector for this function is: 0x5b2eaf4b,427 /// or in textual repr: collectionNestingPermissions()428 function collectionNestingPermissions() public view returns (Tuple37[] memory) {429 require(false, stub_error);430 dummy;431 return new Tuple37[](0);432 }433434 /// Set the collection access method.435 /// @param mode Access mode436 /// 0 for Normal437 /// 1 for AllowList438 /// @dev EVM selector for this function is: 0x41835d4c,439 /// or in textual repr: setCollectionAccess(uint8)440 function setCollectionAccess(uint8 mode) public {441 require(false, stub_error);442 mode;443 dummy = 0;444 }445446 /// Checks that user allowed to operate with collection.447 ///448 /// @param user User address to check.449 /// @dev EVM selector for this function is: 0x91b6df49,450 /// or in textual repr: allowlistedCross((address,uint256))451 function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {452 require(false, stub_error);453 user;454 dummy;455 return false;456 }457458 // /// Add the user to the allowed list.459 // ///460 // /// @param user Address of a trusted user.461 // /// @dev EVM selector for this function is: 0x67844fe6,462 // /// or in textual repr: addToCollectionAllowList(address)463 // function addToCollectionAllowList(address user) public {464 // require(false, stub_error);465 // user;466 // dummy = 0;467 // }468469 /// Add user to allowed list.470 ///471 /// @param user User cross account address.472 /// @dev EVM selector for this function is: 0xa0184a3a,473 /// or in textual repr: addToCollectionAllowListCross((address,uint256))474 function addToCollectionAllowListCross(EthCrossAccount memory user) public {475 require(false, stub_error);476 user;477 dummy = 0;478 }479480 // /// Remove the user from the allowed list.481 // ///482 // /// @param user Address of a removed user.483 // /// @dev EVM selector for this function is: 0x85c51acb,484 // /// or in textual repr: removeFromCollectionAllowList(address)485 // function removeFromCollectionAllowList(address user) public {486 // require(false, stub_error);487 // user;488 // dummy = 0;489 // }490491 /// Remove user from allowed list.492 ///493 /// @param user User cross account address.494 /// @dev EVM selector for this function is: 0x09ba452a,495 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))496 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {497 require(false, stub_error);498 user;499 dummy = 0;500 }501502 /// Switch permission for minting.503 ///504 /// @param mode Enable if "true".505 /// @dev EVM selector for this function is: 0x00018e84,506 /// or in textual repr: setCollectionMintMode(bool)507 function setCollectionMintMode(bool mode) public {508 require(false, stub_error);509 mode;510 dummy = 0;511 }512513 // /// Check that account is the owner or admin of the collection514 // ///515 // /// @param user account to verify516 // /// @return "true" if account is the owner or admin517 // /// @dev EVM selector for this function is: 0x9811b0c7,518 // /// or in textual repr: isOwnerOrAdmin(address)519 // function isOwnerOrAdmin(address user) public view returns (bool) {520 // require(false, stub_error);521 // user;522 // dummy;523 // return false;524 // }525526 /// Check that account is the owner or admin of the collection527 ///528 /// @param user User cross account to verify529 /// @return "true" if account is the owner or admin530 /// @dev EVM selector for this function is: 0x3e75a905,531 /// or in textual repr: isOwnerOrAdminCross((address,uint256))532 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {533 require(false, stub_error);534 user;535 dummy;536 return false;537 }538539 /// Returns collection type540 ///541 /// @return `Fungible` or `NFT` or `ReFungible`542 /// @dev EVM selector for this function is: 0xd34b55b8,543 /// or in textual repr: uniqueCollectionType()544 function uniqueCollectionType() public view returns (string memory) {545 require(false, stub_error);546 dummy;547 return "";548 }549550 /// Get collection owner.551 ///552 /// @return Tuble with sponsor address and his substrate mirror.553 /// If address is canonical then substrate mirror is zero and vice versa.554 /// @dev EVM selector for this function is: 0xdf727d3b,555 /// or in textual repr: collectionOwner()556 function collectionOwner() public view returns (EthCrossAccount memory) {557 require(false, stub_error);558 dummy;559 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);560 }561562 // /// Changes collection owner to another account563 // ///564 // /// @dev Owner can be changed only by current owner565 // /// @param newOwner new owner account566 // /// @dev EVM selector for this function is: 0x4f53e226,567 // /// or in textual repr: changeCollectionOwner(address)568 // function changeCollectionOwner(address newOwner) public {569 // require(false, stub_error);570 // newOwner;571 // dummy = 0;572 // }573574 /// Get collection administrators575 ///576 /// @return Vector of tuples with admins address and his substrate mirror.577 /// If address is canonical then substrate mirror is zero and vice versa.578 /// @dev EVM selector for this function is: 0x5813216b,579 /// or in textual repr: collectionAdmins()580 function collectionAdmins() public view returns (EthCrossAccount[] memory) {581 require(false, stub_error);582 dummy;583 return new EthCrossAccount[](0);584 }585586 /// Changes collection owner to another account587 ///588 /// @dev Owner can be changed only by current owner589 /// @param newOwner new owner cross account590 /// @dev EVM selector for this function is: 0x6496c497,591 /// or in textual repr: changeCollectionOwnerCross((address,uint256))592 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {593 require(false, stub_error);594 newOwner;595 dummy = 0;596 }597}598599/// @dev Cross account struct600struct EthCrossAccount {601 address eth;602 uint256 sub;603}604605enum CollectionPermissions {606 CollectionAdmin,607 TokenOwner608}609610/// @dev anonymous struct611struct Tuple37 {612 CollectionPermissions field_0;613 bool field_1;614}615616/// @dev anonymous struct617struct Tuple34 {618 bool field_0;619 uint256[] field_1;620}621622/// @dev anonymous struct623struct Tuple30 {624 address field_0;625 uint256 field_1;626}627628/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension629/// @dev See https://eips.ethereum.org/EIPS/eip-721630/// @dev the ERC-165 identifier for this interface is 0x5b5e139f631contract ERC721Metadata is Dummy, ERC165 {632 // /// @notice A descriptive name for a collection of NFTs in this contract633 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`634 // /// @dev EVM selector for this function is: 0x06fdde03,635 // /// or in textual repr: name()636 // function name() public view returns (string memory) {637 // require(false, stub_error);638 // dummy;639 // return "";640 // }641642 // /// @notice An abbreviated name for NFTs in this contract643 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`644 // /// @dev EVM selector for this function is: 0x95d89b41,645 // /// or in textual repr: symbol()646 // function symbol() public view returns (string memory) {647 // require(false, stub_error);648 // dummy;649 // return "";650 // }651652 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.653 ///654 /// @dev If the token has a `url` property and it is not empty, it is returned.655 /// 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`.656 /// If the collection property `baseURI` is empty or absent, return "" (empty string)657 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix658 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).659 ///660 /// @return token's const_metadata661 /// @dev EVM selector for this function is: 0xc87b56dd,662 /// or in textual repr: tokenURI(uint256)663 function tokenURI(uint256 tokenId) public view returns (string memory) {664 require(false, stub_error);665 tokenId;666 dummy;667 return "";668 }669}670671/// @title ERC721 Token that can be irreversibly burned (destroyed).672/// @dev the ERC-165 identifier for this interface is 0x42966c68673contract ERC721Burnable is Dummy, ERC165 {674 /// @notice Burns a specific ERC721 token.675 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized676 /// operator of the current owner.677 /// @param tokenId The NFT to approve678 /// @dev EVM selector for this function is: 0x42966c68,679 /// or in textual repr: burn(uint256)680 function burn(uint256 tokenId) public {681 require(false, stub_error);682 tokenId;683 dummy = 0;684 }685}686687/// @dev inlined interface688contract ERC721UniqueMintableEvents {689 event MintingFinished();690}691692/// @title ERC721 minting logic.693/// @dev the ERC-165 identifier for this interface is 0x476ff149694contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {695 /// @dev EVM selector for this function is: 0x05d2035b,696 /// or in textual repr: mintingFinished()697 function mintingFinished() public view returns (bool) {698 require(false, stub_error);699 dummy;700 return false;701 }702703 /// @notice Function to mint token.704 /// @param to The new owner705 /// @return uint256 The id of the newly minted token706 /// @dev EVM selector for this function is: 0x6a627842,707 /// or in textual repr: mint(address)708 function mint(address to) public returns (uint256) {709 require(false, stub_error);710 to;711 dummy = 0;712 return 0;713 }714715 // /// @notice Function to mint token.716 // /// @dev `tokenId` should be obtained with `nextTokenId` method,717 // /// unlike standard, you can't specify it manually718 // /// @param to The new owner719 // /// @param tokenId ID of the minted NFT720 // /// @dev EVM selector for this function is: 0x40c10f19,721 // /// or in textual repr: mint(address,uint256)722 // function mint(address to, uint256 tokenId) public returns (bool) {723 // require(false, stub_error);724 // to;725 // tokenId;726 // dummy = 0;727 // return false;728 // }729730 /// @notice Function to mint token with the given tokenUri.731 /// @param to The new owner732 /// @param tokenUri Token URI that would be stored in the NFT properties733 /// @return uint256 The id of the newly minted token734 /// @dev EVM selector for this function is: 0x45c17782,735 /// or in textual repr: mintWithTokenURI(address,string)736 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {737 require(false, stub_error);738 to;739 tokenUri;740 dummy = 0;741 return 0;742 }743744 // /// @notice Function to mint token with the given tokenUri.745 // /// @dev `tokenId` should be obtained with `nextTokenId` method,746 // /// unlike standard, you can't specify it manually747 // /// @param to The new owner748 // /// @param tokenId ID of the minted NFT749 // /// @param tokenUri Token URI that would be stored in the NFT properties750 // /// @dev EVM selector for this function is: 0x50bb4e7f,751 // /// or in textual repr: mintWithTokenURI(address,uint256,string)752 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {753 // require(false, stub_error);754 // to;755 // tokenId;756 // tokenUri;757 // dummy = 0;758 // return false;759 // }760761 /// @dev Not implemented762 /// @dev EVM selector for this function is: 0x7d64bcb4,763 /// or in textual repr: finishMinting()764 function finishMinting() public returns (bool) {765 require(false, stub_error);766 dummy = 0;767 return false;768 }769}770771/// @title Unique extensions for ERC721.772/// @dev the ERC-165 identifier for this interface is 0xb74c26b7773contract ERC721UniqueExtensions is Dummy, ERC165 {774 /// @notice A descriptive name for a collection of NFTs in this contract775 /// @dev EVM selector for this function is: 0x06fdde03,776 /// or in textual repr: name()777 function name() public view returns (string memory) {778 require(false, stub_error);779 dummy;780 return "";781 }782783 /// @notice An abbreviated name for NFTs in this contract784 /// @dev EVM selector for this function is: 0x95d89b41,785 /// or in textual repr: symbol()786 function symbol() public view returns (string memory) {787 require(false, stub_error);788 dummy;789 return "";790 }791792 /// @notice A description for the collection.793 /// @dev EVM selector for this function is: 0x7284e416,794 /// or in textual repr: description()795 function description() public view returns (string memory) {796 require(false, stub_error);797 dummy;798 return "";799 }800801 /// Returns the owner (in cross format) of the token.802 ///803 /// @param tokenId Id for the token.804 /// @dev EVM selector for this function is: 0x2b29dace,805 /// or in textual repr: crossOwnerOf(uint256)806 function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {807 require(false, stub_error);808 tokenId;809 dummy;810 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);811 }812813 /// Returns the token properties.814 ///815 /// @param tokenId Id for the token.816 /// @param keys Properties keys. Empty keys for all propertyes.817 /// @return Vector of properties key/value pairs.818 /// @dev EVM selector for this function is: 0xe07ede7e,819 /// or in textual repr: properties(uint256,string[])820 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {821 require(false, stub_error);822 tokenId;823 keys;824 dummy;825 return new Property[](0);826 }827828 /// @notice Set or reaffirm the approved address for an NFT829 /// @dev The zero address indicates there is no approved address.830 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized831 /// operator of the current owner.832 /// @param approved The new substrate address approved NFT controller833 /// @param tokenId The NFT to approve834 /// @dev EVM selector for this function is: 0x0ecd0ab0,835 /// or in textual repr: approveCross((address,uint256),uint256)836 function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {837 require(false, stub_error);838 approved;839 tokenId;840 dummy = 0;841 }842843 /// @notice Transfer ownership of an NFT844 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`845 /// is the zero address. Throws if `tokenId` is not a valid NFT.846 /// @param to The new owner847 /// @param tokenId The NFT to transfer848 /// @dev EVM selector for this function is: 0xa9059cbb,849 /// or in textual repr: transfer(address,uint256)850 function transfer(address to, uint256 tokenId) public {851 require(false, stub_error);852 to;853 tokenId;854 dummy = 0;855 }856857 /// @notice Transfer ownership of an NFT858 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`859 /// is the zero address. Throws if `tokenId` is not a valid NFT.860 /// @param to The new owner861 /// @param tokenId The NFT to transfer862 /// @dev EVM selector for this function is: 0x2ada85ff,863 /// or in textual repr: transferCross((address,uint256),uint256)864 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {865 require(false, stub_error);866 to;867 tokenId;868 dummy = 0;869 }870871 /// @notice Transfer ownership of an NFT from cross account address to cross account address872 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`873 /// is the zero address. Throws if `tokenId` is not a valid NFT.874 /// @param from Cross acccount address of current owner875 /// @param to Cross acccount address of new owner876 /// @param tokenId The NFT to transfer877 /// @dev EVM selector for this function is: 0xd5cf430b,878 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)879 function transferFromCross(880 EthCrossAccount memory from,881 EthCrossAccount memory to,882 uint256 tokenId883 ) public {884 require(false, stub_error);885 from;886 to;887 tokenId;888 dummy = 0;889 }890891 // /// @notice Burns a specific ERC721 token.892 // /// @dev Throws unless `msg.sender` is the current owner or an authorized893 // /// operator for this NFT. Throws if `from` is not the current owner. Throws894 // /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.895 // /// @param from The current owner of the NFT896 // /// @param tokenId The NFT to transfer897 // /// @dev EVM selector for this function is: 0x79cc6790,898 // /// or in textual repr: burnFrom(address,uint256)899 // function burnFrom(address from, uint256 tokenId) public {900 // require(false, stub_error);901 // from;902 // tokenId;903 // dummy = 0;904 // }905906 /// @notice Burns a specific ERC721 token.907 /// @dev Throws unless `msg.sender` is the current owner or an authorized908 /// operator for this NFT. Throws if `from` is not the current owner. Throws909 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.910 /// @param from The current owner of the NFT911 /// @param tokenId The NFT to transfer912 /// @dev EVM selector for this function is: 0xbb2f5a58,913 /// or in textual repr: burnFromCross((address,uint256),uint256)914 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {915 require(false, stub_error);916 from;917 tokenId;918 dummy = 0;919 }920921 /// @notice Returns next free NFT ID.922 /// @dev EVM selector for this function is: 0x75794a3c,923 /// or in textual repr: nextTokenId()924 function nextTokenId() public view returns (uint256) {925 require(false, stub_error);926 dummy;927 return 0;928 }929 // /// @notice Function to mint multiple tokens.930 // /// @dev `tokenIds` should be an array of consecutive numbers and first number931 // /// should be obtained with `nextTokenId` method932 // /// @param to The new owner933 // /// @param tokenIds IDs of the minted NFTs934 // /// @dev EVM selector for this function is: 0x44a9945e,935 // /// or in textual repr: mintBulk(address,uint256[])936 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {937 // require(false, stub_error);938 // to;939 // tokenIds;940 // dummy = 0;941 // return false;942 // }943944 // /// @notice Function to mint multiple tokens with the given tokenUris.945 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive946 // /// numbers and first number should be obtained with `nextTokenId` method947 // /// @param to The new owner948 // /// @param tokens array of pairs of token ID and token URI for minted tokens949 // /// @dev EVM selector for this function is: 0x36543006,950 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])951 // function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {952 // require(false, stub_error);953 // to;954 // tokens;955 // dummy = 0;956 // return false;957 // }958959}960961/// @dev anonymous struct962struct Tuple15 {963 uint256 field_0;964 string field_1;965}966967/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension968/// @dev See https://eips.ethereum.org/EIPS/eip-721969/// @dev the ERC-165 identifier for this interface is 0x780e9d63970contract ERC721Enumerable is Dummy, ERC165 {971 /// @notice Enumerate valid NFTs972 /// @param index A counter less than `totalSupply()`973 /// @return The token identifier for the `index`th NFT,974 /// (sort order not specified)975 /// @dev EVM selector for this function is: 0x4f6ccce7,976 /// or in textual repr: tokenByIndex(uint256)977 function tokenByIndex(uint256 index) public view returns (uint256) {978 require(false, stub_error);979 index;980 dummy;981 return 0;982 }983984 /// @dev Not implemented985 /// @dev EVM selector for this function is: 0x2f745c59,986 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)987 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {988 require(false, stub_error);989 owner;990 index;991 dummy;992 return 0;993 }994995 /// @notice Count NFTs tracked by this contract996 /// @return A count of valid NFTs tracked by this contract, where each one of997 /// them has an assigned and queryable owner not equal to the zero address998 /// @dev EVM selector for this function is: 0x18160ddd,999 /// or in textual repr: totalSupply()1000 function totalSupply() public view returns (uint256) {1001 require(false, stub_error);1002 dummy;1003 return 0;1004 }1005}10061007/// @dev inlined interface1008contract ERC721Events {1009 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1010 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1011 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1012}10131014/// @title ERC-721 Non-Fungible Token Standard1015/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1016/// @dev the ERC-165 identifier for this interface is 0x983a942b1017contract ERC721 is Dummy, ERC165, ERC721Events {1018 /// @notice Count all NFTs assigned to an owner1019 /// @dev NFTs assigned to the zero address are considered invalid, and this1020 /// function throws for queries about the zero address.1021 /// @param owner An address for whom to query the balance1022 /// @return The number of NFTs owned by `owner`, possibly zero1023 /// @dev EVM selector for this function is: 0x70a08231,1024 /// or in textual repr: balanceOf(address)1025 function balanceOf(address owner) public view returns (uint256) {1026 require(false, stub_error);1027 owner;1028 dummy;1029 return 0;1030 }10311032 /// @notice Find the owner of an NFT1033 /// @dev NFTs assigned to zero address are considered invalid, and queries1034 /// about them do throw.1035 /// @param tokenId The identifier for an NFT1036 /// @return The address of the owner of the NFT1037 /// @dev EVM selector for this function is: 0x6352211e,1038 /// or in textual repr: ownerOf(uint256)1039 function ownerOf(uint256 tokenId) public view returns (address) {1040 require(false, stub_error);1041 tokenId;1042 dummy;1043 return 0x0000000000000000000000000000000000000000;1044 }10451046 /// @dev Not implemented1047 /// @dev EVM selector for this function is: 0xb88d4fde,1048 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)1049 function safeTransferFrom(1050 address from,1051 address to,1052 uint256 tokenId,1053 bytes memory data1054 ) public {1055 require(false, stub_error);1056 from;1057 to;1058 tokenId;1059 data;1060 dummy = 0;1061 }10621063 /// @dev Not implemented1064 /// @dev EVM selector for this function is: 0x42842e0e,1065 /// or in textual repr: safeTransferFrom(address,address,uint256)1066 function safeTransferFrom(1067 address from,1068 address to,1069 uint256 tokenId1070 ) public {1071 require(false, stub_error);1072 from;1073 to;1074 tokenId;1075 dummy = 0;1076 }10771078 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1079 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1080 /// THEY MAY BE PERMANENTLY LOST1081 /// @dev Throws unless `msg.sender` is the current owner or an authorized1082 /// operator for this NFT. Throws if `from` is not the current owner. Throws1083 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1084 /// @param from The current owner of the NFT1085 /// @param to The new owner1086 /// @param tokenId The NFT to transfer1087 /// @dev EVM selector for this function is: 0x23b872dd,1088 /// or in textual repr: transferFrom(address,address,uint256)1089 function transferFrom(1090 address from,1091 address to,1092 uint256 tokenId1093 ) public {1094 require(false, stub_error);1095 from;1096 to;1097 tokenId;1098 dummy = 0;1099 }11001101 /// @notice Set or reaffirm the approved address for an NFT1102 /// @dev The zero address indicates there is no approved address.1103 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1104 /// operator of the current owner.1105 /// @param approved The new approved NFT controller1106 /// @param tokenId The NFT to approve1107 /// @dev EVM selector for this function is: 0x095ea7b3,1108 /// or in textual repr: approve(address,uint256)1109 function approve(address approved, uint256 tokenId) public {1110 require(false, stub_error);1111 approved;1112 tokenId;1113 dummy = 0;1114 }11151116 /// @notice Sets or unsets the approval of a given operator.1117 /// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1118 /// @param operator Operator1119 /// @param approved Should operator status be granted or revoked?1120 /// @dev EVM selector for this function is: 0xa22cb465,1121 /// or in textual repr: setApprovalForAll(address,bool)1122 function setApprovalForAll(address operator, bool approved) public {1123 require(false, stub_error);1124 operator;1125 approved;1126 dummy = 0;1127 }11281129 /// @dev Not implemented1130 /// @dev EVM selector for this function is: 0x081812fc,1131 /// or in textual repr: getApproved(uint256)1132 function getApproved(uint256 tokenId) public view returns (address) {1133 require(false, stub_error);1134 tokenId;1135 dummy;1136 return 0x0000000000000000000000000000000000000000;1137 }11381139 /// @notice Tells whether the given `owner` approves the `operator`.1140 /// @dev EVM selector for this function is: 0xe985e9c5,1141 /// or in textual repr: isApprovedForAll(address,address)1142 function isApprovedForAll(address owner, address operator) public view returns (bool) {1143 require(false, stub_error);1144 owner;1145 operator;1146 dummy;1147 return false;1148 }11491150 /// @notice Returns collection helper contract address1151 /// @dev EVM selector for this function is: 0x1896cce6,1152 /// or in textual repr: collectionHelperAddress()1153 function collectionHelperAddress() public view returns (address) {1154 require(false, stub_error);1155 dummy;1156 return 0x0000000000000000000000000000000000000000;1157 }1158}11591160contract UniqueNFT is1161 Dummy,1162 ERC165,1163 ERC721,1164 ERC721Enumerable,1165 ERC721UniqueExtensions,1166 ERC721UniqueMintable,1167 ERC721Burnable,1168 ERC721Metadata,1169 Collection,1170 TokenProperties1171{}