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(53 uint256 tokenId,54 string memory key,55 bytes memory value56 ) public {57 require(false, stub_error);58 tokenId;59 key;60 value;61 dummy = 0;62 }6364 /// @notice Set token properties value.65 /// @dev Throws error if `msg.sender` has no permission to edit the property.66 /// @param tokenId ID of the token.67 /// @param properties settable properties68 /// @dev EVM selector for this function is: 0x14ed3a6e,69 /// or in textual repr: setProperties(uint256,(string,bytes)[])70 function setProperties(uint256 tokenId, Tuple22[] memory properties) public {71 require(false, stub_error);72 tokenId;73 properties;74 dummy = 0;75 }7677 // /// @notice Delete token property value.78 // /// @dev Throws error if `msg.sender` has no permission to edit the property.79 // /// @param tokenId ID of the token.80 // /// @param key Property key.81 // /// @dev EVM selector for this function is: 0x066111d1,82 // /// or in textual repr: deleteProperty(uint256,string)83 // function deleteProperty(uint256 tokenId, string memory key) public {84 // require(false, stub_error);85 // tokenId;86 // key;87 // dummy = 0;88 // }8990 /// @notice Delete token properties value.91 /// @dev Throws error if `msg.sender` has no permission to edit the property.92 /// @param tokenId ID of the token.93 /// @param keys Properties key.94 /// @dev EVM selector for this function is: 0xc472d371,95 /// or in textual repr: deleteProperties(uint256,string[])96 function deleteProperties(uint256 tokenId, string[] memory keys) public {97 require(false, stub_error);98 tokenId;99 keys;100 dummy = 0;101 }102103 /// @notice Get token property value.104 /// @dev Throws error if key not found105 /// @param tokenId ID of the token.106 /// @param key Property key.107 /// @return Property value bytes108 /// @dev EVM selector for this function is: 0x7228c327,109 /// or in textual repr: property(uint256,string)110 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {111 require(false, stub_error);112 tokenId;113 key;114 dummy;115 return hex"";116 }117}118119/// @title A contract that allows you to work with collections.120/// @dev the ERC-165 identifier for this interface is 0xb3152af3121contract Collection is Dummy, ERC165 {122 /// Set collection property.123 ///124 /// @param key Property key.125 /// @param value Propery value.126 /// @dev EVM selector for this function is: 0x2f073f66,127 /// or in textual repr: setCollectionProperty(string,bytes)128 function setCollectionProperty(string memory key, bytes memory value) public {129 require(false, stub_error);130 key;131 value;132 dummy = 0;133 }134135 /// Set collection properties.136 ///137 /// @param properties Vector of properties key/value pair.138 /// @dev EVM selector for this function is: 0x50b26b2a,139 /// or in textual repr: setCollectionProperties((string,bytes)[])140 function setCollectionProperties(Tuple22[] memory properties) public {141 require(false, stub_error);142 properties;143 dummy = 0;144 }145146 /// Delete collection property.147 ///148 /// @param key Property key.149 /// @dev EVM selector for this function is: 0x7b7debce,150 /// or in textual repr: deleteCollectionProperty(string)151 function deleteCollectionProperty(string memory key) public {152 require(false, stub_error);153 key;154 dummy = 0;155 }156157 /// Delete collection properties.158 ///159 /// @param keys Properties keys.160 /// @dev EVM selector for this function is: 0xee206ee3,161 /// or in textual repr: deleteCollectionProperties(string[])162 function deleteCollectionProperties(string[] memory keys) public {163 require(false, stub_error);164 keys;165 dummy = 0;166 }167168 /// Get collection property.169 ///170 /// @dev Throws error if key not found.171 ///172 /// @param key Property key.173 /// @return bytes The property corresponding to the key.174 /// @dev EVM selector for this function is: 0xcf24fd6d,175 /// or in textual repr: collectionProperty(string)176 function collectionProperty(string memory key) public view returns (bytes memory) {177 require(false, stub_error);178 key;179 dummy;180 return hex"";181 }182183 /// Get collection properties.184 ///185 /// @param keys Properties keys. Empty keys for all propertyes.186 /// @return Vector of properties key/value pairs.187 /// @dev EVM selector for this function is: 0x285fb8e6,188 /// or in textual repr: collectionProperties(string[])189 function collectionProperties(string[] memory keys) public view returns (Tuple22[] memory) {190 require(false, stub_error);191 keys;192 dummy;193 return new Tuple22[](0);194 }195196 /// Set the sponsor of the collection.197 ///198 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.199 ///200 /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.201 /// @dev EVM selector for this function is: 0x7623402e,202 /// or in textual repr: setCollectionSponsor(address)203 function setCollectionSponsor(address sponsor) public {204 require(false, stub_error);205 sponsor;206 dummy = 0;207 }208209 /// Set the sponsor of the collection.210 ///211 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.212 ///213 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.214 /// @dev EVM selector for this function is: 0x84a1d5a8,215 /// or in textual repr: setCollectionSponsorCross((address,uint256))216 function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {217 require(false, stub_error);218 sponsor;219 dummy = 0;220 }221222 /// Whether there is a pending sponsor.223 /// @dev EVM selector for this function is: 0x058ac185,224 /// or in textual repr: hasCollectionPendingSponsor()225 function hasCollectionPendingSponsor() public view returns (bool) {226 require(false, stub_error);227 dummy;228 return false;229 }230231 /// Collection sponsorship confirmation.232 ///233 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.234 /// @dev EVM selector for this function is: 0x3c50e97a,235 /// or in textual repr: confirmCollectionSponsorship()236 function confirmCollectionSponsorship() public {237 require(false, stub_error);238 dummy = 0;239 }240241 /// Remove collection sponsor.242 /// @dev EVM selector for this function is: 0x6e0326a3,243 /// or in textual repr: removeCollectionSponsor()244 function removeCollectionSponsor() public {245 require(false, stub_error);246 dummy = 0;247 }248249 /// Get current sponsor.250 ///251 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.252 /// @dev EVM selector for this function is: 0x6ec0a9f1,253 /// or in textual repr: collectionSponsor()254 function collectionSponsor() public view returns (Tuple25 memory) {255 require(false, stub_error);256 dummy;257 return Tuple25(0x0000000000000000000000000000000000000000, 0);258 }259260 /// Set limits for the collection.261 /// @dev Throws error if limit not found.262 /// @param limit Name of the limit. Valid names:263 /// "accountTokenOwnershipLimit",264 /// "sponsoredDataSize",265 /// "sponsoredDataRateLimit",266 /// "tokenLimit",267 /// "sponsorTransferTimeout",268 /// "sponsorApproveTimeout"269 /// @param value Value of the limit.270 /// @dev EVM selector for this function is: 0x6a3841db,271 /// or in textual repr: setCollectionLimit(string,uint32)272 function setCollectionLimit(string memory limit, uint32 value) public {273 require(false, stub_error);274 limit;275 value;276 dummy = 0;277 }278279 /// Set limits for the collection.280 /// @dev Throws error if limit not found.281 /// @param limit Name of the limit. Valid names:282 /// "ownerCanTransfer",283 /// "ownerCanDestroy",284 /// "transfersEnabled"285 /// @param value Value of the limit.286 /// @dev EVM selector for this function is: 0x993b7fba,287 /// or in textual repr: setCollectionLimit(string,bool)288 function setCollectionLimit(string memory limit, bool value) public {289 require(false, stub_error);290 limit;291 value;292 dummy = 0;293 }294295 /// Get contract address.296 /// @dev EVM selector for this function is: 0xf6b4dfb4,297 /// or in textual repr: contractAddress()298 function contractAddress() public view returns (address) {299 require(false, stub_error);300 dummy;301 return 0x0000000000000000000000000000000000000000;302 }303304 /// Add collection admin.305 /// @param newAdmin Cross account administrator address.306 /// @dev EVM selector for this function is: 0x859aa7d6,307 /// or in textual repr: addCollectionAdminCross((address,uint256))308 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {309 require(false, stub_error);310 newAdmin;311 dummy = 0;312 }313314 /// Remove collection admin.315 /// @param admin Cross account administrator address.316 /// @dev EVM selector for this function is: 0x6c0cd173,317 /// or in textual repr: removeCollectionAdminCross((address,uint256))318 function removeCollectionAdminCross(EthCrossAccount memory admin) public {319 require(false, stub_error);320 admin;321 dummy = 0;322 }323324 /// Add collection admin.325 /// @param newAdmin Address of the added administrator.326 /// @dev EVM selector for this function is: 0x92e462c7,327 /// or in textual repr: addCollectionAdmin(address)328 function addCollectionAdmin(address newAdmin) public {329 require(false, stub_error);330 newAdmin;331 dummy = 0;332 }333334 /// Remove collection admin.335 ///336 /// @param admin Address of the removed administrator.337 /// @dev EVM selector for this function is: 0xfafd7b42,338 /// or in textual repr: removeCollectionAdmin(address)339 function removeCollectionAdmin(address admin) public {340 require(false, stub_error);341 admin;342 dummy = 0;343 }344345 /// Toggle accessibility of collection nesting.346 ///347 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'348 /// @dev EVM selector for this function is: 0x112d4586,349 /// or in textual repr: setCollectionNesting(bool)350 function setCollectionNesting(bool enable) public {351 require(false, stub_error);352 enable;353 dummy = 0;354 }355356 /// Toggle accessibility of collection nesting.357 ///358 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'359 /// @param collections Addresses of collections that will be available for nesting.360 /// @dev EVM selector for this function is: 0x64872396,361 /// or in textual repr: setCollectionNesting(bool,address[])362 function setCollectionNesting(bool enable, address[] memory collections) public {363 require(false, stub_error);364 enable;365 collections;366 dummy = 0;367 }368369 /// Set the collection access method.370 /// @param mode Access mode371 /// 0 for Normal372 /// 1 for AllowList373 /// @dev EVM selector for this function is: 0x41835d4c,374 /// or in textual repr: setCollectionAccess(uint8)375 function setCollectionAccess(uint8 mode) public {376 require(false, stub_error);377 mode;378 dummy = 0;379 }380381 /// Checks that user allowed to operate with collection.382 ///383 /// @param user User address to check.384 /// @dev EVM selector for this function is: 0xd63a8e11,385 /// or in textual repr: allowed(address)386 function allowed(address user) public view returns (bool) {387 require(false, stub_error);388 user;389 dummy;390 return false;391 }392393 /// Add the user to the allowed list.394 ///395 /// @param user Address of a trusted user.396 /// @dev EVM selector for this function is: 0x67844fe6,397 /// or in textual repr: addToCollectionAllowList(address)398 function addToCollectionAllowList(address user) public {399 require(false, stub_error);400 user;401 dummy = 0;402 }403404 /// Add user to allowed list.405 ///406 /// @param user User cross account address.407 /// @dev EVM selector for this function is: 0xa0184a3a,408 /// or in textual repr: addToCollectionAllowListCross((address,uint256))409 function addToCollectionAllowListCross(EthCrossAccount memory user) public {410 require(false, stub_error);411 user;412 dummy = 0;413 }414415 /// Remove the user from the allowed list.416 ///417 /// @param user Address of a removed user.418 /// @dev EVM selector for this function is: 0x85c51acb,419 /// or in textual repr: removeFromCollectionAllowList(address)420 function removeFromCollectionAllowList(address user) public {421 require(false, stub_error);422 user;423 dummy = 0;424 }425426 /// Remove user from allowed list.427 ///428 /// @param user User cross account address.429 /// @dev EVM selector for this function is: 0x09ba452a,430 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))431 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {432 require(false, stub_error);433 user;434 dummy = 0;435 }436437 /// Switch permission for minting.438 ///439 /// @param mode Enable if "true".440 /// @dev EVM selector for this function is: 0x00018e84,441 /// or in textual repr: setCollectionMintMode(bool)442 function setCollectionMintMode(bool mode) public {443 require(false, stub_error);444 mode;445 dummy = 0;446 }447448 /// Check that account is the owner or admin of the collection449 ///450 /// @param user account to verify451 /// @return "true" if account is the owner or admin452 /// @dev EVM selector for this function is: 0x9811b0c7,453 /// or in textual repr: isOwnerOrAdmin(address)454 function isOwnerOrAdmin(address user) public view returns (bool) {455 require(false, stub_error);456 user;457 dummy;458 return false;459 }460461 /// Check that account is the owner or admin of the collection462 ///463 /// @param user User cross account to verify464 /// @return "true" if account is the owner or admin465 /// @dev EVM selector for this function is: 0x3e75a905,466 /// or in textual repr: isOwnerOrAdminCross((address,uint256))467 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {468 require(false, stub_error);469 user;470 dummy;471 return false;472 }473474 /// Returns collection type475 ///476 /// @return `Fungible` or `NFT` or `ReFungible`477 /// @dev EVM selector for this function is: 0xd34b55b8,478 /// or in textual repr: uniqueCollectionType()479 function uniqueCollectionType() public view returns (string memory) {480 require(false, stub_error);481 dummy;482 return "";483 }484485 /// Get collection owner.486 ///487 /// @return Tuble with sponsor address and his substrate mirror.488 /// If address is canonical then substrate mirror is zero and vice versa.489 /// @dev EVM selector for this function is: 0xdf727d3b,490 /// or in textual repr: collectionOwner()491 function collectionOwner() public view returns (EthCrossAccount memory) {492 require(false, stub_error);493 dummy;494 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);495 }496497 /// Changes collection owner to another account498 ///499 /// @dev Owner can be changed only by current owner500 /// @param newOwner new owner account501 /// @dev EVM selector for this function is: 0x4f53e226,502 /// or in textual repr: changeCollectionOwner(address)503 function changeCollectionOwner(address newOwner) public {504 require(false, stub_error);505 newOwner;506 dummy = 0;507 }508509 /// Get collection administrators510 ///511 /// @return Vector of tuples with admins address and his substrate mirror.512 /// If address is canonical then substrate mirror is zero and vice versa.513 /// @dev EVM selector for this function is: 0x5813216b,514 /// or in textual repr: collectionAdmins()515 function collectionAdmins() public view returns (EthCrossAccount[] memory) {516 require(false, stub_error);517 dummy;518 return new EthCrossAccount[](0);519 }520521 /// Changes collection owner to another account522 ///523 /// @dev Owner can be changed only by current owner524 /// @param newOwner new owner cross account525 /// @dev EVM selector for this function is: 0xe5c9913f,526 /// or in textual repr: setOwnerCross((address,uint256))527 function setOwnerCross(EthCrossAccount memory newOwner) public {528 require(false, stub_error);529 newOwner;530 dummy = 0;531 }532}533534/// @dev Cross account struct535struct EthCrossAccount {536 address eth;537 uint256 sub;538}539540/// @dev anonymous struct541struct Tuple25 {542 address field_0;543 uint256 field_1;544}545546/// @dev anonymous struct547struct Tuple22 {548 string field_0;549 bytes field_1;550}551552/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension553/// @dev See https://eips.ethereum.org/EIPS/eip-721554/// @dev the ERC-165 identifier for this interface is 0x5b5e139f555contract ERC721Metadata is Dummy, ERC165 {556 // /// @notice A descriptive name for a collection of NFTs in this contract557 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`558 // /// @dev EVM selector for this function is: 0x06fdde03,559 // /// or in textual repr: name()560 // function name() public view returns (string memory) {561 // require(false, stub_error);562 // dummy;563 // return "";564 // }565566 // /// @notice An abbreviated name for NFTs in this contract567 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`568 // /// @dev EVM selector for this function is: 0x95d89b41,569 // /// or in textual repr: symbol()570 // function symbol() public view returns (string memory) {571 // require(false, stub_error);572 // dummy;573 // return "";574 // }575576 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.577 ///578 /// @dev If the token has a `url` property and it is not empty, it is returned.579 /// 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`.580 /// If the collection property `baseURI` is empty or absent, return "" (empty string)581 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix582 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).583 ///584 /// @return token's const_metadata585 /// @dev EVM selector for this function is: 0xc87b56dd,586 /// or in textual repr: tokenURI(uint256)587 function tokenURI(uint256 tokenId) public view returns (string memory) {588 require(false, stub_error);589 tokenId;590 dummy;591 return "";592 }593}594595/// @title ERC721 Token that can be irreversibly burned (destroyed).596/// @dev the ERC-165 identifier for this interface is 0x42966c68597contract ERC721Burnable is Dummy, ERC165 {598 /// @notice Burns a specific ERC721 token.599 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized600 /// operator of the current owner.601 /// @param tokenId The NFT to approve602 /// @dev EVM selector for this function is: 0x42966c68,603 /// or in textual repr: burn(uint256)604 function burn(uint256 tokenId) public {605 require(false, stub_error);606 tokenId;607 dummy = 0;608 }609}610611/// @dev inlined interface612contract ERC721UniqueMintableEvents {613 event MintingFinished();614}615616/// @title ERC721 minting logic.617/// @dev the ERC-165 identifier for this interface is 0x476ff149618contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {619 /// @dev EVM selector for this function is: 0x05d2035b,620 /// or in textual repr: mintingFinished()621 function mintingFinished() public view returns (bool) {622 require(false, stub_error);623 dummy;624 return false;625 }626627 /// @notice Function to mint token.628 /// @param to The new owner629 /// @return uint256 The id of the newly minted token630 /// @dev EVM selector for this function is: 0x6a627842,631 /// or in textual repr: mint(address)632 function mint(address to) public returns (uint256) {633 require(false, stub_error);634 to;635 dummy = 0;636 return 0;637 }638639 // /// @notice Function to mint token.640 // /// @dev `tokenId` should be obtained with `nextTokenId` method,641 // /// unlike standard, you can't specify it manually642 // /// @param to The new owner643 // /// @param tokenId ID of the minted NFT644 // /// @dev EVM selector for this function is: 0x40c10f19,645 // /// or in textual repr: mint(address,uint256)646 // function mint(address to, uint256 tokenId) public returns (bool) {647 // require(false, stub_error);648 // to;649 // tokenId;650 // dummy = 0;651 // return false;652 // }653654 /// @notice Function to mint token with the given tokenUri.655 /// @param to The new owner656 /// @param tokenUri Token URI that would be stored in the NFT properties657 /// @return uint256 The id of the newly minted token658 /// @dev EVM selector for this function is: 0x45c17782,659 /// or in textual repr: mintWithTokenURI(address,string)660 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {661 require(false, stub_error);662 to;663 tokenUri;664 dummy = 0;665 return 0;666 }667668 // /// @notice Function to mint token with the given tokenUri.669 // /// @dev `tokenId` should be obtained with `nextTokenId` method,670 // /// unlike standard, you can't specify it manually671 // /// @param to The new owner672 // /// @param tokenId ID of the minted NFT673 // /// @param tokenUri Token URI that would be stored in the NFT properties674 // /// @dev EVM selector for this function is: 0x50bb4e7f,675 // /// or in textual repr: mintWithTokenURI(address,uint256,string)676 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {677 // require(false, stub_error);678 // to;679 // tokenId;680 // tokenUri;681 // dummy = 0;682 // return false;683 // }684685 /// @dev Not implemented686 /// @dev EVM selector for this function is: 0x7d64bcb4,687 /// or in textual repr: finishMinting()688 function finishMinting() public returns (bool) {689 require(false, stub_error);690 dummy = 0;691 return false;692 }693}694695/// @title Unique extensions for ERC721.696/// @dev the ERC-165 identifier for this interface is 0x0e9fc611697contract ERC721UniqueExtensions is Dummy, ERC165 {698 /// @notice A descriptive name for a collection of NFTs in this contract699 /// @dev EVM selector for this function is: 0x06fdde03,700 /// or in textual repr: name()701 function name() public view returns (string memory) {702 require(false, stub_error);703 dummy;704 return "";705 }706707 /// @notice An abbreviated name for NFTs in this contract708 /// @dev EVM selector for this function is: 0x95d89b41,709 /// or in textual repr: symbol()710 function symbol() public view returns (string memory) {711 require(false, stub_error);712 dummy;713 return "";714 }715716 /// @notice Set or reaffirm the approved address for an NFT717 /// @dev The zero address indicates there is no approved address.718 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized719 /// operator of the current owner.720 /// @param approved The new substrate address approved NFT controller721 /// @param tokenId The NFT to approve722 /// @dev EVM selector for this function is: 0x0ecd0ab0,723 /// or in textual repr: approveCross((address,uint256),uint256)724 function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {725 require(false, stub_error);726 approved;727 tokenId;728 dummy = 0;729 }730731 /// @notice Transfer ownership of an NFT732 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`733 /// is the zero address. Throws if `tokenId` is not a valid NFT.734 /// @param to The new owner735 /// @param tokenId The NFT to transfer736 /// @dev EVM selector for this function is: 0xa9059cbb,737 /// or in textual repr: transfer(address,uint256)738 function transfer(address to, uint256 tokenId) public {739 require(false, stub_error);740 to;741 tokenId;742 dummy = 0;743 }744745 /// @notice Transfer ownership of an NFT746 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`747 /// is the zero address. Throws if `tokenId` is not a valid NFT.748 /// @param to The new owner749 /// @param tokenId The NFT to transfer750 /// @dev EVM selector for this function is: 0x2ada85ff,751 /// or in textual repr: transferCross((address,uint256),uint256)752 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {753 require(false, stub_error);754 to;755 tokenId;756 dummy = 0;757 }758759 /// @notice Transfer ownership of an NFT from cross account address to cross account address760 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`761 /// is the zero address. Throws if `tokenId` is not a valid NFT.762 /// @param from Cross acccount address of current owner763 /// @param to Cross acccount address of new owner764 /// @param tokenId The NFT to transfer765 /// @dev EVM selector for this function is: 0xd5cf430b,766 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)767 function transferFromCross(768 EthCrossAccount memory from,769 EthCrossAccount memory to,770 uint256 tokenId771 ) public {772 require(false, stub_error);773 from;774 to;775 tokenId;776 dummy = 0;777 }778779 /// @notice Burns a specific ERC721 token.780 /// @dev Throws unless `msg.sender` is the current owner or an authorized781 /// operator for this NFT. Throws if `from` is not the current owner. Throws782 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.783 /// @param from The current owner of the NFT784 /// @param tokenId The NFT to transfer785 /// @dev EVM selector for this function is: 0x79cc6790,786 /// or in textual repr: burnFrom(address,uint256)787 function burnFrom(address from, uint256 tokenId) public {788 require(false, stub_error);789 from;790 tokenId;791 dummy = 0;792 }793794 /// @notice Burns a specific ERC721 token.795 /// @dev Throws unless `msg.sender` is the current owner or an authorized796 /// operator for this NFT. Throws if `from` is not the current owner. Throws797 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.798 /// @param from The current owner of the NFT799 /// @param tokenId The NFT to transfer800 /// @dev EVM selector for this function is: 0xbb2f5a58,801 /// or in textual repr: burnFromCross((address,uint256),uint256)802 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {803 require(false, stub_error);804 from;805 tokenId;806 dummy = 0;807 }808809 /// @notice Returns next free NFT ID.810 /// @dev EVM selector for this function is: 0x75794a3c,811 /// or in textual repr: nextTokenId()812 function nextTokenId() public view returns (uint256) {813 require(false, stub_error);814 dummy;815 return 0;816 }817 // /// @notice Function to mint multiple tokens.818 // /// @dev `tokenIds` should be an array of consecutive numbers and first number819 // /// should be obtained with `nextTokenId` method820 // /// @param to The new owner821 // /// @param tokenIds IDs of the minted NFTs822 // /// @dev EVM selector for this function is: 0x44a9945e,823 // /// or in textual repr: mintBulk(address,uint256[])824 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {825 // require(false, stub_error);826 // to;827 // tokenIds;828 // dummy = 0;829 // return false;830 // }831832 // /// @notice Function to mint multiple tokens with the given tokenUris.833 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive834 // /// numbers and first number should be obtained with `nextTokenId` method835 // /// @param to The new owner836 // /// @param tokens array of pairs of token ID and token URI for minted tokens837 // /// @dev EVM selector for this function is: 0x36543006,838 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])839 // function mintBulkWithTokenURI(address to, Tuple11[] memory tokens) public returns (bool) {840 // require(false, stub_error);841 // to;842 // tokens;843 // dummy = 0;844 // return false;845 // }846847}848849/// @dev anonymous struct850struct Tuple11 {851 uint256 field_0;852 string field_1;853}854855/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension856/// @dev See https://eips.ethereum.org/EIPS/eip-721857/// @dev the ERC-165 identifier for this interface is 0x780e9d63858contract ERC721Enumerable is Dummy, ERC165 {859 /// @notice Enumerate valid NFTs860 /// @param index A counter less than `totalSupply()`861 /// @return The token identifier for the `index`th NFT,862 /// (sort order not specified)863 /// @dev EVM selector for this function is: 0x4f6ccce7,864 /// or in textual repr: tokenByIndex(uint256)865 function tokenByIndex(uint256 index) public view returns (uint256) {866 require(false, stub_error);867 index;868 dummy;869 return 0;870 }871872 /// @dev Not implemented873 /// @dev EVM selector for this function is: 0x2f745c59,874 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)875 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {876 require(false, stub_error);877 owner;878 index;879 dummy;880 return 0;881 }882883 /// @notice Count NFTs tracked by this contract884 /// @return A count of valid NFTs tracked by this contract, where each one of885 /// them has an assigned and queryable owner not equal to the zero address886 /// @dev EVM selector for this function is: 0x18160ddd,887 /// or in textual repr: totalSupply()888 function totalSupply() public view returns (uint256) {889 require(false, stub_error);890 dummy;891 return 0;892 }893}894895/// @dev inlined interface896contract ERC721Events {897 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);898 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);899 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);900}901902/// @title ERC-721 Non-Fungible Token Standard903/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md904/// @dev the ERC-165 identifier for this interface is 0x80ac58cd905contract ERC721 is Dummy, ERC165, ERC721Events {906 /// @notice Count all NFTs assigned to an owner907 /// @dev NFTs assigned to the zero address are considered invalid, and this908 /// function throws for queries about the zero address.909 /// @param owner An address for whom to query the balance910 /// @return The number of NFTs owned by `owner`, possibly zero911 /// @dev EVM selector for this function is: 0x70a08231,912 /// or in textual repr: balanceOf(address)913 function balanceOf(address owner) public view returns (uint256) {914 require(false, stub_error);915 owner;916 dummy;917 return 0;918 }919920 /// @notice Find the owner of an NFT921 /// @dev NFTs assigned to zero address are considered invalid, and queries922 /// about them do throw.923 /// @param tokenId The identifier for an NFT924 /// @return The address of the owner of the NFT925 /// @dev EVM selector for this function is: 0x6352211e,926 /// or in textual repr: ownerOf(uint256)927 function ownerOf(uint256 tokenId) public view returns (address) {928 require(false, stub_error);929 tokenId;930 dummy;931 return 0x0000000000000000000000000000000000000000;932 }933934 /// @dev Not implemented935 /// @dev EVM selector for this function is: 0xb88d4fde,936 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)937 function safeTransferFrom(938 address from,939 address to,940 uint256 tokenId,941 bytes memory data942 ) public {943 require(false, stub_error);944 from;945 to;946 tokenId;947 data;948 dummy = 0;949 }950951 /// @dev Not implemented952 /// @dev EVM selector for this function is: 0x42842e0e,953 /// or in textual repr: safeTransferFrom(address,address,uint256)954 function safeTransferFrom(955 address from,956 address to,957 uint256 tokenId958 ) public {959 require(false, stub_error);960 from;961 to;962 tokenId;963 dummy = 0;964 }965966 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE967 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE968 /// THEY MAY BE PERMANENTLY LOST969 /// @dev Throws unless `msg.sender` is the current owner or an authorized970 /// operator for this NFT. Throws if `from` is not the current owner. Throws971 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.972 /// @param from The current owner of the NFT973 /// @param to The new owner974 /// @param tokenId The NFT to transfer975 /// @dev EVM selector for this function is: 0x23b872dd,976 /// or in textual repr: transferFrom(address,address,uint256)977 function transferFrom(978 address from,979 address to,980 uint256 tokenId981 ) public {982 require(false, stub_error);983 from;984 to;985 tokenId;986 dummy = 0;987 }988989 /// @notice Set or reaffirm the approved address for an NFT990 /// @dev The zero address indicates there is no approved address.991 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized992 /// operator of the current owner.993 /// @param approved The new approved NFT controller994 /// @param tokenId The NFT to approve995 /// @dev EVM selector for this function is: 0x095ea7b3,996 /// or in textual repr: approve(address,uint256)997 function approve(address approved, uint256 tokenId) public {998 require(false, stub_error);999 approved;1000 tokenId;1001 dummy = 0;1002 }10031004 /// @dev Not implemented1005 /// @dev EVM selector for this function is: 0xa22cb465,1006 /// or in textual repr: setApprovalForAll(address,bool)1007 function setApprovalForAll(address operator, bool approved) public {1008 require(false, stub_error);1009 operator;1010 approved;1011 dummy = 0;1012 }10131014 /// @dev Not implemented1015 /// @dev EVM selector for this function is: 0x081812fc,1016 /// or in textual repr: getApproved(uint256)1017 function getApproved(uint256 tokenId) public view returns (address) {1018 require(false, stub_error);1019 tokenId;1020 dummy;1021 return 0x0000000000000000000000000000000000000000;1022 }10231024 /// @dev Not implemented1025 /// @dev EVM selector for this function is: 0xe985e9c5,1026 /// or in textual repr: isApprovedForAll(address,address)1027 function isApprovedForAll(address owner, address operator) public view returns (address) {1028 require(false, stub_error);1029 owner;1030 operator;1031 dummy;1032 return 0x0000000000000000000000000000000000000000;1033 }1034}10351036contract UniqueNFT is1037 Dummy,1038 ERC165,1039 ERC721,1040 ERC721Enumerable,1041 ERC721UniqueExtensions,1042 ERC721UniqueMintable,1043 ERC721Burnable,1044 ERC721Metadata,1045 Collection,1046 TokenProperties1047{}