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 /// Set limits for the collection.295 /// @dev Throws error if limit not found.296 /// @param limit Name of the limit. Valid names:297 /// "accountTokenOwnershipLimit",298 /// "sponsoredDataSize",299 /// "sponsoredDataRateLimit",300 /// "tokenLimit",301 /// "sponsorTransferTimeout",302 /// "sponsorApproveTimeout"303 /// "ownerCanTransfer",304 /// "ownerCanDestroy",305 /// "transfersEnabled"306 /// @param value Value of the limit.307 /// @dev EVM selector for this function is: 0x4ad890a8,308 /// or in textual repr: setCollectionLimit(string,uint256)309 function setCollectionLimit(string memory limit, uint256 value) public {310 require(false, stub_error);311 limit;312 value;313 dummy = 0;314 }315316 /// Get contract address.317 /// @dev EVM selector for this function is: 0xf6b4dfb4,318 /// or in textual repr: contractAddress()319 function contractAddress() public view returns (address) {320 require(false, stub_error);321 dummy;322 return 0x0000000000000000000000000000000000000000;323 }324325 /// Add collection admin.326 /// @param newAdmin Cross account administrator address.327 /// @dev EVM selector for this function is: 0x859aa7d6,328 /// or in textual repr: addCollectionAdminCross((address,uint256))329 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {330 require(false, stub_error);331 newAdmin;332 dummy = 0;333 }334335 /// Remove collection admin.336 /// @param admin Cross account administrator address.337 /// @dev EVM selector for this function is: 0x6c0cd173,338 /// or in textual repr: removeCollectionAdminCross((address,uint256))339 function removeCollectionAdminCross(EthCrossAccount memory admin) public {340 require(false, stub_error);341 admin;342 dummy = 0;343 }344345 // /// Add collection admin.346 // /// @param newAdmin Address of the added administrator.347 // /// @dev EVM selector for this function is: 0x92e462c7,348 // /// or in textual repr: addCollectionAdmin(address)349 // function addCollectionAdmin(address newAdmin) public {350 // require(false, stub_error);351 // newAdmin;352 // dummy = 0;353 // }354355 // /// Remove collection admin.356 // ///357 // /// @param admin Address of the removed administrator.358 // /// @dev EVM selector for this function is: 0xfafd7b42,359 // /// or in textual repr: removeCollectionAdmin(address)360 // function removeCollectionAdmin(address admin) public {361 // require(false, stub_error);362 // admin;363 // dummy = 0;364 // }365366 /// Toggle accessibility of collection nesting.367 ///368 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'369 /// @dev EVM selector for this function is: 0x112d4586,370 /// or in textual repr: setCollectionNesting(bool)371 function setCollectionNesting(bool enable) public {372 require(false, stub_error);373 enable;374 dummy = 0;375 }376377 /// Toggle accessibility of collection nesting.378 ///379 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'380 /// @param collections Addresses of collections that will be available for nesting.381 /// @dev EVM selector for this function is: 0x64872396,382 /// or in textual repr: setCollectionNesting(bool,address[])383 function setCollectionNesting(bool enable, address[] memory collections) public {384 require(false, stub_error);385 enable;386 collections;387 dummy = 0;388 }389390 /// Returns nesting for a collection391 /// @dev EVM selector for this function is: 0x22d25bfe,392 /// or in textual repr: collectionNestingRestrictedCollectionIds()393 function collectionNestingRestrictedCollectionIds() public view returns (Tuple34 memory) {394 require(false, stub_error);395 dummy;396 return Tuple34(false, new uint256[](0));397 }398399 /// Returns permissions for a collection400 /// @dev EVM selector for this function is: 0x5b2eaf4b,401 /// or in textual repr: collectionNestingPermissions()402 function collectionNestingPermissions() public view returns (Tuple37[] memory) {403 require(false, stub_error);404 dummy;405 return new Tuple37[](0);406 }407408 /// Set the collection access method.409 /// @param mode Access mode410 /// 0 for Normal411 /// 1 for AllowList412 /// @dev EVM selector for this function is: 0x41835d4c,413 /// or in textual repr: setCollectionAccess(uint8)414 function setCollectionAccess(uint8 mode) public {415 require(false, stub_error);416 mode;417 dummy = 0;418 }419420 /// Checks that user allowed to operate with collection.421 ///422 /// @param user User address to check.423 /// @dev EVM selector for this function is: 0x91b6df49,424 /// or in textual repr: allowlistedCross((address,uint256))425 function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {426 require(false, stub_error);427 user;428 dummy;429 return false;430 }431432 // /// Add the user to the allowed list.433 // ///434 // /// @param user Address of a trusted user.435 // /// @dev EVM selector for this function is: 0x67844fe6,436 // /// or in textual repr: addToCollectionAllowList(address)437 // function addToCollectionAllowList(address user) public {438 // require(false, stub_error);439 // user;440 // dummy = 0;441 // }442443 /// Add user to allowed list.444 ///445 /// @param user User cross account address.446 /// @dev EVM selector for this function is: 0xa0184a3a,447 /// or in textual repr: addToCollectionAllowListCross((address,uint256))448 function addToCollectionAllowListCross(EthCrossAccount memory user) public {449 require(false, stub_error);450 user;451 dummy = 0;452 }453454 // /// Remove the user from the allowed list.455 // ///456 // /// @param user Address of a removed user.457 // /// @dev EVM selector for this function is: 0x85c51acb,458 // /// or in textual repr: removeFromCollectionAllowList(address)459 // function removeFromCollectionAllowList(address user) public {460 // require(false, stub_error);461 // user;462 // dummy = 0;463 // }464465 /// Remove user from allowed list.466 ///467 /// @param user User cross account address.468 /// @dev EVM selector for this function is: 0x09ba452a,469 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))470 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {471 require(false, stub_error);472 user;473 dummy = 0;474 }475476 /// Switch permission for minting.477 ///478 /// @param mode Enable if "true".479 /// @dev EVM selector for this function is: 0x00018e84,480 /// or in textual repr: setCollectionMintMode(bool)481 function setCollectionMintMode(bool mode) public {482 require(false, stub_error);483 mode;484 dummy = 0;485 }486487 // /// Check that account is the owner or admin of the collection488 // ///489 // /// @param user account to verify490 // /// @return "true" if account is the owner or admin491 // /// @dev EVM selector for this function is: 0x9811b0c7,492 // /// or in textual repr: isOwnerOrAdmin(address)493 // function isOwnerOrAdmin(address user) public view returns (bool) {494 // require(false, stub_error);495 // user;496 // dummy;497 // return false;498 // }499500 /// Check that account is the owner or admin of the collection501 ///502 /// @param user User cross account to verify503 /// @return "true" if account is the owner or admin504 /// @dev EVM selector for this function is: 0x3e75a905,505 /// or in textual repr: isOwnerOrAdminCross((address,uint256))506 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {507 require(false, stub_error);508 user;509 dummy;510 return false;511 }512513 /// Returns collection type514 ///515 /// @return `Fungible` or `NFT` or `ReFungible`516 /// @dev EVM selector for this function is: 0xd34b55b8,517 /// or in textual repr: uniqueCollectionType()518 function uniqueCollectionType() public view returns (string memory) {519 require(false, stub_error);520 dummy;521 return "";522 }523524 /// Get collection owner.525 ///526 /// @return Tuble with sponsor address and his substrate mirror.527 /// If address is canonical then substrate mirror is zero and vice versa.528 /// @dev EVM selector for this function is: 0xdf727d3b,529 /// or in textual repr: collectionOwner()530 function collectionOwner() public view returns (EthCrossAccount memory) {531 require(false, stub_error);532 dummy;533 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);534 }535536 // /// Changes collection owner to another account537 // ///538 // /// @dev Owner can be changed only by current owner539 // /// @param newOwner new owner account540 // /// @dev EVM selector for this function is: 0x4f53e226,541 // /// or in textual repr: changeCollectionOwner(address)542 // function changeCollectionOwner(address newOwner) public {543 // require(false, stub_error);544 // newOwner;545 // dummy = 0;546 // }547548 /// Get collection administrators549 ///550 /// @return Vector of tuples with admins address and his substrate mirror.551 /// If address is canonical then substrate mirror is zero and vice versa.552 /// @dev EVM selector for this function is: 0x5813216b,553 /// or in textual repr: collectionAdmins()554 function collectionAdmins() public view returns (EthCrossAccount[] memory) {555 require(false, stub_error);556 dummy;557 return new EthCrossAccount[](0);558 }559560 /// Changes collection owner to another account561 ///562 /// @dev Owner can be changed only by current owner563 /// @param newOwner new owner cross account564 /// @dev EVM selector for this function is: 0x6496c497,565 /// or in textual repr: changeCollectionOwnerCross((address,uint256))566 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {567 require(false, stub_error);568 newOwner;569 dummy = 0;570 }571}572573/// @dev Cross account struct574struct EthCrossAccount {575 address eth;576 uint256 sub;577}578579enum CollectionPermissions {580 CollectionAdmin,581 TokenOwner582}583584/// @dev anonymous struct585struct Tuple37 {586 CollectionPermissions field_0;587 bool field_1;588}589590/// @dev anonymous struct591struct Tuple34 {592 bool field_0;593 uint256[] field_1;594}595596/// @dev anonymous struct597struct Tuple30 {598 address field_0;599 uint256 field_1;600}601602/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension603/// @dev See https://eips.ethereum.org/EIPS/eip-721604/// @dev the ERC-165 identifier for this interface is 0x5b5e139f605contract ERC721Metadata is Dummy, ERC165 {606 // /// @notice A descriptive name for a collection of NFTs in this contract607 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`608 // /// @dev EVM selector for this function is: 0x06fdde03,609 // /// or in textual repr: name()610 // function name() public view returns (string memory) {611 // require(false, stub_error);612 // dummy;613 // return "";614 // }615616 // /// @notice An abbreviated name for NFTs in this contract617 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`618 // /// @dev EVM selector for this function is: 0x95d89b41,619 // /// or in textual repr: symbol()620 // function symbol() public view returns (string memory) {621 // require(false, stub_error);622 // dummy;623 // return "";624 // }625626 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.627 ///628 /// @dev If the token has a `url` property and it is not empty, it is returned.629 /// 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`.630 /// If the collection property `baseURI` is empty or absent, return "" (empty string)631 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix632 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).633 ///634 /// @return token's const_metadata635 /// @dev EVM selector for this function is: 0xc87b56dd,636 /// or in textual repr: tokenURI(uint256)637 function tokenURI(uint256 tokenId) public view returns (string memory) {638 require(false, stub_error);639 tokenId;640 dummy;641 return "";642 }643}644645/// @title ERC721 Token that can be irreversibly burned (destroyed).646/// @dev the ERC-165 identifier for this interface is 0x42966c68647contract ERC721Burnable is Dummy, ERC165 {648 /// @notice Burns a specific ERC721 token.649 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized650 /// operator of the current owner.651 /// @param tokenId The NFT to approve652 /// @dev EVM selector for this function is: 0x42966c68,653 /// or in textual repr: burn(uint256)654 function burn(uint256 tokenId) public {655 require(false, stub_error);656 tokenId;657 dummy = 0;658 }659}660661/// @dev inlined interface662contract ERC721UniqueMintableEvents {663 event MintingFinished();664}665666/// @title ERC721 minting logic.667/// @dev the ERC-165 identifier for this interface is 0x476ff149668contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {669 /// @dev EVM selector for this function is: 0x05d2035b,670 /// or in textual repr: mintingFinished()671 function mintingFinished() public view returns (bool) {672 require(false, stub_error);673 dummy;674 return false;675 }676677 /// @notice Function to mint token.678 /// @param to The new owner679 /// @return uint256 The id of the newly minted token680 /// @dev EVM selector for this function is: 0x6a627842,681 /// or in textual repr: mint(address)682 function mint(address to) public returns (uint256) {683 require(false, stub_error);684 to;685 dummy = 0;686 return 0;687 }688689 // /// @notice Function to mint token.690 // /// @dev `tokenId` should be obtained with `nextTokenId` method,691 // /// unlike standard, you can't specify it manually692 // /// @param to The new owner693 // /// @param tokenId ID of the minted NFT694 // /// @dev EVM selector for this function is: 0x40c10f19,695 // /// or in textual repr: mint(address,uint256)696 // function mint(address to, uint256 tokenId) public returns (bool) {697 // require(false, stub_error);698 // to;699 // tokenId;700 // dummy = 0;701 // return false;702 // }703704 /// @notice Function to mint token with the given tokenUri.705 /// @param to The new owner706 /// @param tokenUri Token URI that would be stored in the NFT properties707 /// @return uint256 The id of the newly minted token708 /// @dev EVM selector for this function is: 0x45c17782,709 /// or in textual repr: mintWithTokenURI(address,string)710 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {711 require(false, stub_error);712 to;713 tokenUri;714 dummy = 0;715 return 0;716 }717718 // /// @notice Function to mint token with the given tokenUri.719 // /// @dev `tokenId` should be obtained with `nextTokenId` method,720 // /// unlike standard, you can't specify it manually721 // /// @param to The new owner722 // /// @param tokenId ID of the minted NFT723 // /// @param tokenUri Token URI that would be stored in the NFT properties724 // /// @dev EVM selector for this function is: 0x50bb4e7f,725 // /// or in textual repr: mintWithTokenURI(address,uint256,string)726 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {727 // require(false, stub_error);728 // to;729 // tokenId;730 // tokenUri;731 // dummy = 0;732 // return false;733 // }734735 /// @dev Not implemented736 /// @dev EVM selector for this function is: 0x7d64bcb4,737 /// or in textual repr: finishMinting()738 function finishMinting() public returns (bool) {739 require(false, stub_error);740 dummy = 0;741 return false;742 }743}744745/// @title Unique extensions for ERC721.746/// @dev the ERC-165 identifier for this interface is 0xb74c26b7747contract ERC721UniqueExtensions is Dummy, ERC165 {748 /// @notice A descriptive name for a collection of NFTs in this contract749 /// @dev EVM selector for this function is: 0x06fdde03,750 /// or in textual repr: name()751 function name() public view returns (string memory) {752 require(false, stub_error);753 dummy;754 return "";755 }756757 /// @notice An abbreviated name for NFTs in this contract758 /// @dev EVM selector for this function is: 0x95d89b41,759 /// or in textual repr: symbol()760 function symbol() public view returns (string memory) {761 require(false, stub_error);762 dummy;763 return "";764 }765766 /// @notice A description for the collection.767 /// @dev EVM selector for this function is: 0x7284e416,768 /// or in textual repr: description()769 function description() public view returns (string memory) {770 require(false, stub_error);771 dummy;772 return "";773 }774775 /// Returns the owner (in cross format) of the token.776 ///777 /// @param tokenId Id for the token.778 /// @dev EVM selector for this function is: 0x2b29dace,779 /// or in textual repr: crossOwnerOf(uint256)780 function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {781 require(false, stub_error);782 tokenId;783 dummy;784 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);785 }786787 /// Returns the token properties.788 ///789 /// @param tokenId Id for the token.790 /// @param keys Properties keys. Empty keys for all propertyes.791 /// @return Vector of properties key/value pairs.792 /// @dev EVM selector for this function is: 0xe07ede7e,793 /// or in textual repr: properties(uint256,string[])794 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {795 require(false, stub_error);796 tokenId;797 keys;798 dummy;799 return new Property[](0);800 }801802 /// @notice Set or reaffirm the approved address for an NFT803 /// @dev The zero address indicates there is no approved address.804 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized805 /// operator of the current owner.806 /// @param approved The new substrate address approved NFT controller807 /// @param tokenId The NFT to approve808 /// @dev EVM selector for this function is: 0x0ecd0ab0,809 /// or in textual repr: approveCross((address,uint256),uint256)810 function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {811 require(false, stub_error);812 approved;813 tokenId;814 dummy = 0;815 }816817 /// @notice Transfer ownership of an NFT818 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`819 /// is the zero address. Throws if `tokenId` is not a valid NFT.820 /// @param to The new owner821 /// @param tokenId The NFT to transfer822 /// @dev EVM selector for this function is: 0xa9059cbb,823 /// or in textual repr: transfer(address,uint256)824 function transfer(address to, uint256 tokenId) public {825 require(false, stub_error);826 to;827 tokenId;828 dummy = 0;829 }830831 /// @notice Transfer ownership of an NFT832 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`833 /// is the zero address. Throws if `tokenId` is not a valid NFT.834 /// @param to The new owner835 /// @param tokenId The NFT to transfer836 /// @dev EVM selector for this function is: 0x2ada85ff,837 /// or in textual repr: transferCross((address,uint256),uint256)838 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {839 require(false, stub_error);840 to;841 tokenId;842 dummy = 0;843 }844845 /// @notice Transfer ownership of an NFT from cross account address to cross account address846 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`847 /// is the zero address. Throws if `tokenId` is not a valid NFT.848 /// @param from Cross acccount address of current owner849 /// @param to Cross acccount address of new owner850 /// @param tokenId The NFT to transfer851 /// @dev EVM selector for this function is: 0xd5cf430b,852 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)853 function transferFromCross(854 EthCrossAccount memory from,855 EthCrossAccount memory to,856 uint256 tokenId857 ) public {858 require(false, stub_error);859 from;860 to;861 tokenId;862 dummy = 0;863 }864865 // /// @notice Burns a specific ERC721 token.866 // /// @dev Throws unless `msg.sender` is the current owner or an authorized867 // /// operator for this NFT. Throws if `from` is not the current owner. Throws868 // /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.869 // /// @param from The current owner of the NFT870 // /// @param tokenId The NFT to transfer871 // /// @dev EVM selector for this function is: 0x79cc6790,872 // /// or in textual repr: burnFrom(address,uint256)873 // function burnFrom(address from, uint256 tokenId) public {874 // require(false, stub_error);875 // from;876 // tokenId;877 // dummy = 0;878 // }879880 /// @notice Burns a specific ERC721 token.881 /// @dev Throws unless `msg.sender` is the current owner or an authorized882 /// operator for this NFT. Throws if `from` is not the current owner. Throws883 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.884 /// @param from The current owner of the NFT885 /// @param tokenId The NFT to transfer886 /// @dev EVM selector for this function is: 0xbb2f5a58,887 /// or in textual repr: burnFromCross((address,uint256),uint256)888 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {889 require(false, stub_error);890 from;891 tokenId;892 dummy = 0;893 }894895 /// @notice Returns next free NFT ID.896 /// @dev EVM selector for this function is: 0x75794a3c,897 /// or in textual repr: nextTokenId()898 function nextTokenId() public view returns (uint256) {899 require(false, stub_error);900 dummy;901 return 0;902 }903 // /// @notice Function to mint multiple tokens.904 // /// @dev `tokenIds` should be an array of consecutive numbers and first number905 // /// should be obtained with `nextTokenId` method906 // /// @param to The new owner907 // /// @param tokenIds IDs of the minted NFTs908 // /// @dev EVM selector for this function is: 0x44a9945e,909 // /// or in textual repr: mintBulk(address,uint256[])910 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {911 // require(false, stub_error);912 // to;913 // tokenIds;914 // dummy = 0;915 // return false;916 // }917918 // /// @notice Function to mint multiple tokens with the given tokenUris.919 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive920 // /// numbers and first number should be obtained with `nextTokenId` method921 // /// @param to The new owner922 // /// @param tokens array of pairs of token ID and token URI for minted tokens923 // /// @dev EVM selector for this function is: 0x36543006,924 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])925 // function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {926 // require(false, stub_error);927 // to;928 // tokens;929 // dummy = 0;930 // return false;931 // }932933}934935/// @dev anonymous struct936struct Tuple15 {937 uint256 field_0;938 string field_1;939}940941/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension942/// @dev See https://eips.ethereum.org/EIPS/eip-721943/// @dev the ERC-165 identifier for this interface is 0x780e9d63944contract ERC721Enumerable is Dummy, ERC165 {945 /// @notice Enumerate valid NFTs946 /// @param index A counter less than `totalSupply()`947 /// @return The token identifier for the `index`th NFT,948 /// (sort order not specified)949 /// @dev EVM selector for this function is: 0x4f6ccce7,950 /// or in textual repr: tokenByIndex(uint256)951 function tokenByIndex(uint256 index) public view returns (uint256) {952 require(false, stub_error);953 index;954 dummy;955 return 0;956 }957958 /// @dev Not implemented959 /// @dev EVM selector for this function is: 0x2f745c59,960 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)961 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {962 require(false, stub_error);963 owner;964 index;965 dummy;966 return 0;967 }968969 /// @notice Count NFTs tracked by this contract970 /// @return A count of valid NFTs tracked by this contract, where each one of971 /// them has an assigned and queryable owner not equal to the zero address972 /// @dev EVM selector for this function is: 0x18160ddd,973 /// or in textual repr: totalSupply()974 function totalSupply() public view returns (uint256) {975 require(false, stub_error);976 dummy;977 return 0;978 }979}980981/// @dev inlined interface982contract ERC721Events {983 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);984 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);985 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);986}987988/// @title ERC-721 Non-Fungible Token Standard989/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md990/// @dev the ERC-165 identifier for this interface is 0x983a942b991contract ERC721 is Dummy, ERC165, ERC721Events {992 /// @notice Count all NFTs assigned to an owner993 /// @dev NFTs assigned to the zero address are considered invalid, and this994 /// function throws for queries about the zero address.995 /// @param owner An address for whom to query the balance996 /// @return The number of NFTs owned by `owner`, possibly zero997 /// @dev EVM selector for this function is: 0x70a08231,998 /// or in textual repr: balanceOf(address)999 function balanceOf(address owner) public view returns (uint256) {1000 require(false, stub_error);1001 owner;1002 dummy;1003 return 0;1004 }10051006 /// @notice Find the owner of an NFT1007 /// @dev NFTs assigned to zero address are considered invalid, and queries1008 /// about them do throw.1009 /// @param tokenId The identifier for an NFT1010 /// @return The address of the owner of the NFT1011 /// @dev EVM selector for this function is: 0x6352211e,1012 /// or in textual repr: ownerOf(uint256)1013 function ownerOf(uint256 tokenId) public view returns (address) {1014 require(false, stub_error);1015 tokenId;1016 dummy;1017 return 0x0000000000000000000000000000000000000000;1018 }10191020 /// @dev Not implemented1021 /// @dev EVM selector for this function is: 0xb88d4fde,1022 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)1023 function safeTransferFrom(1024 address from,1025 address to,1026 uint256 tokenId,1027 bytes memory data1028 ) public {1029 require(false, stub_error);1030 from;1031 to;1032 tokenId;1033 data;1034 dummy = 0;1035 }10361037 /// @dev Not implemented1038 /// @dev EVM selector for this function is: 0x42842e0e,1039 /// or in textual repr: safeTransferFrom(address,address,uint256)1040 function safeTransferFrom(1041 address from,1042 address to,1043 uint256 tokenId1044 ) public {1045 require(false, stub_error);1046 from;1047 to;1048 tokenId;1049 dummy = 0;1050 }10511052 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1053 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1054 /// THEY MAY BE PERMANENTLY LOST1055 /// @dev Throws unless `msg.sender` is the current owner or an authorized1056 /// operator for this NFT. Throws if `from` is not the current owner. Throws1057 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1058 /// @param from The current owner of the NFT1059 /// @param to The new owner1060 /// @param tokenId The NFT to transfer1061 /// @dev EVM selector for this function is: 0x23b872dd,1062 /// or in textual repr: transferFrom(address,address,uint256)1063 function transferFrom(1064 address from,1065 address to,1066 uint256 tokenId1067 ) public {1068 require(false, stub_error);1069 from;1070 to;1071 tokenId;1072 dummy = 0;1073 }10741075 /// @notice Set or reaffirm the approved address for an NFT1076 /// @dev The zero address indicates there is no approved address.1077 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1078 /// operator of the current owner.1079 /// @param approved The new approved NFT controller1080 /// @param tokenId The NFT to approve1081 /// @dev EVM selector for this function is: 0x095ea7b3,1082 /// or in textual repr: approve(address,uint256)1083 function approve(address approved, uint256 tokenId) public {1084 require(false, stub_error);1085 approved;1086 tokenId;1087 dummy = 0;1088 }10891090 /// @notice Sets or unsets the approval of a given operator.1091 /// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1092 /// @param operator Operator1093 /// @param approved Should operator status be granted or revoked?1094 /// @dev EVM selector for this function is: 0xa22cb465,1095 /// or in textual repr: setApprovalForAll(address,bool)1096 function setApprovalForAll(address operator, bool approved) public {1097 require(false, stub_error);1098 operator;1099 approved;1100 dummy = 0;1101 }11021103 /// @dev Not implemented1104 /// @dev EVM selector for this function is: 0x081812fc,1105 /// or in textual repr: getApproved(uint256)1106 function getApproved(uint256 tokenId) public view returns (address) {1107 require(false, stub_error);1108 tokenId;1109 dummy;1110 return 0x0000000000000000000000000000000000000000;1111 }11121113 /// @notice Tells whether the given `owner` approves the `operator`.1114 /// @dev EVM selector for this function is: 0xe985e9c5,1115 /// or in textual repr: isApprovedForAll(address,address)1116 function isApprovedForAll(address owner, address operator) public view returns (bool) {1117 require(false, stub_error);1118 owner;1119 operator;1120 dummy;1121 return false;1122 }11231124 /// @notice Returns collection helper contract address1125 /// @dev EVM selector for this function is: 0x1896cce6,1126 /// or in textual repr: collectionHelperAddress()1127 function collectionHelperAddress() public view returns (address) {1128 require(false, stub_error);1129 dummy;1130 return 0x0000000000000000000000000000000000000000;1131 }1132}11331134contract UniqueNFT is1135 Dummy,1136 ERC165,1137 ERC721,1138 ERC721Enumerable,1139 ERC721UniqueExtensions,1140 ERC721UniqueMintable,1141 ERC721Burnable,1142 ERC721Metadata,1143 Collection,1144 TokenProperties1145{}