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, Tuple21[] 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(Tuple21[] 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 (Tuple21[] memory) {190 require(false, stub_error);191 keys;192 dummy;193 return new Tuple21[](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 (Tuple24 memory) {255 require(false, stub_error);256 dummy;257 return Tuple24(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 Tuple24 {542 address field_0;543 uint256 field_1;544}545546/// @dev anonymous struct547struct Tuple21 {548 string field_0;549 bytes field_1;550}551552/// @dev the ERC-165 identifier for this interface is 0x5b5e139f553contract ERC721Metadata is Dummy, ERC165 {554 // /// @notice A descriptive name for a collection of NFTs in this contract555 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`556 // /// @dev EVM selector for this function is: 0x06fdde03,557 // /// or in textual repr: name()558 // function name() public view returns (string memory) {559 // require(false, stub_error);560 // dummy;561 // return "";562 // }563564 // /// @notice An abbreviated name for NFTs in this contract565 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`566 // /// @dev EVM selector for this function is: 0x95d89b41,567 // /// or in textual repr: symbol()568 // function symbol() public view returns (string memory) {569 // require(false, stub_error);570 // dummy;571 // return "";572 // }573574 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.575 ///576 /// @dev If the token has a `url` property and it is not empty, it is returned.577 /// 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`.578 /// If the collection property `baseURI` is empty or absent, return "" (empty string)579 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix580 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).581 ///582 /// @return token's const_metadata583 /// @dev EVM selector for this function is: 0xc87b56dd,584 /// or in textual repr: tokenURI(uint256)585 function tokenURI(uint256 tokenId) public view returns (string memory) {586 require(false, stub_error);587 tokenId;588 dummy;589 return "";590 }591}592593/// @title ERC721 Token that can be irreversibly burned (destroyed).594/// @dev the ERC-165 identifier for this interface is 0x42966c68595contract ERC721Burnable is Dummy, ERC165 {596 /// @notice Burns a specific ERC721 token.597 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized598 /// operator of the current owner.599 /// @param tokenId The RFT to approve600 /// @dev EVM selector for this function is: 0x42966c68,601 /// or in textual repr: burn(uint256)602 function burn(uint256 tokenId) public {603 require(false, stub_error);604 tokenId;605 dummy = 0;606 }607}608609/// @dev inlined interface610contract ERC721UniqueMintableEvents {611 event MintingFinished();612}613614/// @title ERC721 minting logic.615/// @dev the ERC-165 identifier for this interface is 0x476ff149616contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {617 /// @dev EVM selector for this function is: 0x05d2035b,618 /// or in textual repr: mintingFinished()619 function mintingFinished() public view returns (bool) {620 require(false, stub_error);621 dummy;622 return false;623 }624625 /// @notice Function to mint token.626 /// @param to The new owner627 /// @return uint256 The id of the newly minted token628 /// @dev EVM selector for this function is: 0x6a627842,629 /// or in textual repr: mint(address)630 function mint(address to) public returns (uint256) {631 require(false, stub_error);632 to;633 dummy = 0;634 return 0;635 }636637 // /// @notice Function to mint token.638 // /// @dev `tokenId` should be obtained with `nextTokenId` method,639 // /// unlike standard, you can't specify it manually640 // /// @param to The new owner641 // /// @param tokenId ID of the minted RFT642 // /// @dev EVM selector for this function is: 0x40c10f19,643 // /// or in textual repr: mint(address,uint256)644 // function mint(address to, uint256 tokenId) public returns (bool) {645 // require(false, stub_error);646 // to;647 // tokenId;648 // dummy = 0;649 // return false;650 // }651652 /// @notice Function to mint token with the given tokenUri.653 /// @param to The new owner654 /// @param tokenUri Token URI that would be stored in the NFT properties655 /// @return uint256 The id of the newly minted token656 /// @dev EVM selector for this function is: 0x45c17782,657 /// or in textual repr: mintWithTokenURI(address,string)658 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {659 require(false, stub_error);660 to;661 tokenUri;662 dummy = 0;663 return 0;664 }665666 // /// @notice Function to mint token with the given tokenUri.667 // /// @dev `tokenId` should be obtained with `nextTokenId` method,668 // /// unlike standard, you can't specify it manually669 // /// @param to The new owner670 // /// @param tokenId ID of the minted RFT671 // /// @param tokenUri Token URI that would be stored in the RFT properties672 // /// @dev EVM selector for this function is: 0x50bb4e7f,673 // /// or in textual repr: mintWithTokenURI(address,uint256,string)674 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {675 // require(false, stub_error);676 // to;677 // tokenId;678 // tokenUri;679 // dummy = 0;680 // return false;681 // }682683 /// @dev Not implemented684 /// @dev EVM selector for this function is: 0x7d64bcb4,685 /// or in textual repr: finishMinting()686 function finishMinting() public returns (bool) {687 require(false, stub_error);688 dummy = 0;689 return false;690 }691}692693/// @title Unique extensions for ERC721.694/// @dev the ERC-165 identifier for this interface is 0xab243667695contract ERC721UniqueExtensions is Dummy, ERC165 {696 /// @notice A descriptive name for a collection of NFTs in this contract697 /// @dev EVM selector for this function is: 0x06fdde03,698 /// or in textual repr: name()699 function name() public view returns (string memory) {700 require(false, stub_error);701 dummy;702 return "";703 }704705 /// @notice An abbreviated name for NFTs in this contract706 /// @dev EVM selector for this function is: 0x95d89b41,707 /// or in textual repr: symbol()708 function symbol() public view returns (string memory) {709 require(false, stub_error);710 dummy;711 return "";712 }713714 /// @notice Transfer ownership of an RFT715 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`716 /// is the zero address. Throws if `tokenId` is not a valid RFT.717 /// Throws if RFT pieces have multiple owners.718 /// @param to The new owner719 /// @param tokenId The RFT to transfer720 /// @dev EVM selector for this function is: 0xa9059cbb,721 /// or in textual repr: transfer(address,uint256)722 function transfer(address to, uint256 tokenId) public {723 require(false, stub_error);724 to;725 tokenId;726 dummy = 0;727 }728729 /// @notice Transfer ownership of an RFT730 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`731 /// is the zero address. Throws if `tokenId` is not a valid RFT.732 /// Throws if RFT pieces have multiple owners.733 /// @param to The new owner734 /// @param tokenId The RFT to transfer735 /// @dev EVM selector for this function is: 0x2ada85ff,736 /// or in textual repr: transferCross((address,uint256),uint256)737 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {738 require(false, stub_error);739 to;740 tokenId;741 dummy = 0;742 }743744 /// @notice Transfer ownership of an RFT745 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`746 /// is the zero address. Throws if `tokenId` is not a valid RFT.747 /// Throws if RFT pieces have multiple owners.748 /// @param to The new owner749 /// @param tokenId The RFT to transfer750 /// @dev EVM selector for this function is: 0xd5cf430b,751 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)752 function transferFromCross(753 EthCrossAccount memory from,754 EthCrossAccount memory to,755 uint256 tokenId756 ) public {757 require(false, stub_error);758 from;759 to;760 tokenId;761 dummy = 0;762 }763764 /// @notice Burns a specific ERC721 token.765 /// @dev Throws unless `msg.sender` is the current owner or an authorized766 /// operator for this RFT. Throws if `from` is not the current owner. Throws767 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.768 /// Throws if RFT pieces have multiple owners.769 /// @param from The current owner of the RFT770 /// @param tokenId The RFT to transfer771 /// @dev EVM selector for this function is: 0x79cc6790,772 /// or in textual repr: burnFrom(address,uint256)773 function burnFrom(address from, uint256 tokenId) public {774 require(false, stub_error);775 from;776 tokenId;777 dummy = 0;778 }779780 /// @notice Burns a specific ERC721 token.781 /// @dev Throws unless `msg.sender` is the current owner or an authorized782 /// operator for this RFT. Throws if `from` is not the current owner. Throws783 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.784 /// Throws if RFT pieces have multiple owners.785 /// @param from The current owner of the RFT786 /// @param tokenId The RFT to transfer787 /// @dev EVM selector for this function is: 0xbb2f5a58,788 /// or in textual repr: burnFromCross((address,uint256),uint256)789 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {790 require(false, stub_error);791 from;792 tokenId;793 dummy = 0;794 }795796 /// @notice Returns next free RFT ID.797 /// @dev EVM selector for this function is: 0x75794a3c,798 /// or in textual repr: nextTokenId()799 function nextTokenId() public view returns (uint256) {800 require(false, stub_error);801 dummy;802 return 0;803 }804805 // /// @notice Function to mint multiple tokens.806 // /// @dev `tokenIds` should be an array of consecutive numbers and first number807 // /// should be obtained with `nextTokenId` method808 // /// @param to The new owner809 // /// @param tokenIds IDs of the minted RFTs810 // /// @dev EVM selector for this function is: 0x44a9945e,811 // /// or in textual repr: mintBulk(address,uint256[])812 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {813 // require(false, stub_error);814 // to;815 // tokenIds;816 // dummy = 0;817 // return false;818 // }819820 // /// @notice Function to mint multiple tokens with the given tokenUris.821 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive822 // /// numbers and first number should be obtained with `nextTokenId` method823 // /// @param to The new owner824 // /// @param tokens array of pairs of token ID and token URI for minted tokens825 // /// @dev EVM selector for this function is: 0x36543006,826 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])827 // function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) public returns (bool) {828 // require(false, stub_error);829 // to;830 // tokens;831 // dummy = 0;832 // return false;833 // }834835 /// Returns EVM address for refungible token836 ///837 /// @param token ID of the token838 /// @dev EVM selector for this function is: 0xab76fac6,839 /// or in textual repr: tokenContractAddress(uint256)840 function tokenContractAddress(uint256 token) public view returns (address) {841 require(false, stub_error);842 token;843 dummy;844 return 0x0000000000000000000000000000000000000000;845 }846}847848/// @dev anonymous struct849struct Tuple10 {850 uint256 field_0;851 string field_1;852}853854/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension855/// @dev See https://eips.ethereum.org/EIPS/eip-721856/// @dev the ERC-165 identifier for this interface is 0x780e9d63857contract ERC721Enumerable is Dummy, ERC165 {858 /// @notice Enumerate valid RFTs859 /// @param index A counter less than `totalSupply()`860 /// @return The token identifier for the `index`th NFT,861 /// (sort order not specified)862 /// @dev EVM selector for this function is: 0x4f6ccce7,863 /// or in textual repr: tokenByIndex(uint256)864 function tokenByIndex(uint256 index) public view returns (uint256) {865 require(false, stub_error);866 index;867 dummy;868 return 0;869 }870871 /// Not implemented872 /// @dev EVM selector for this function is: 0x2f745c59,873 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)874 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {875 require(false, stub_error);876 owner;877 index;878 dummy;879 return 0;880 }881882 /// @notice Count RFTs tracked by this contract883 /// @return A count of valid RFTs tracked by this contract, where each one of884 /// them has an assigned and queryable owner not equal to the zero address885 /// @dev EVM selector for this function is: 0x18160ddd,886 /// or in textual repr: totalSupply()887 function totalSupply() public view returns (uint256) {888 require(false, stub_error);889 dummy;890 return 0;891 }892}893894/// @dev inlined interface895contract ERC721Events {896 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);897 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);898 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);899}900901/// @title ERC-721 Non-Fungible Token Standard902/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md903/// @dev the ERC-165 identifier for this interface is 0x58800161904contract ERC721 is Dummy, ERC165, ERC721Events {905 /// @notice Count all RFTs assigned to an owner906 /// @dev RFTs assigned to the zero address are considered invalid, and this907 /// function throws for queries about the zero address.908 /// @param owner An address for whom to query the balance909 /// @return The number of RFTs owned by `owner`, possibly zero910 /// @dev EVM selector for this function is: 0x70a08231,911 /// or in textual repr: balanceOf(address)912 function balanceOf(address owner) public view returns (uint256) {913 require(false, stub_error);914 owner;915 dummy;916 return 0;917 }918919 /// @notice Find the owner of an RFT920 /// @dev RFTs assigned to zero address are considered invalid, and queries921 /// about them do throw.922 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for923 /// the tokens that are partially owned.924 /// @param tokenId The identifier for an RFT925 /// @return The address of the owner of the RFT926 /// @dev EVM selector for this function is: 0x6352211e,927 /// or in textual repr: ownerOf(uint256)928 function ownerOf(uint256 tokenId) public view returns (address) {929 require(false, stub_error);930 tokenId;931 dummy;932 return 0x0000000000000000000000000000000000000000;933 }934935 /// @dev Not implemented936 /// @dev EVM selector for this function is: 0x60a11672,937 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)938 function safeTransferFromWithData(939 address from,940 address to,941 uint256 tokenId,942 bytes memory data943 ) public {944 require(false, stub_error);945 from;946 to;947 tokenId;948 data;949 dummy = 0;950 }951952 /// @dev Not implemented953 /// @dev EVM selector for this function is: 0x42842e0e,954 /// or in textual repr: safeTransferFrom(address,address,uint256)955 function safeTransferFrom(956 address from,957 address to,958 uint256 tokenId959 ) public {960 require(false, stub_error);961 from;962 to;963 tokenId;964 dummy = 0;965 }966967 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE968 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE969 /// THEY MAY BE PERMANENTLY LOST970 /// @dev Throws unless `msg.sender` is the current owner or an authorized971 /// operator for this RFT. Throws if `from` is not the current owner. Throws972 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.973 /// Throws if RFT pieces have multiple owners.974 /// @param from The current owner of the NFT975 /// @param to The new owner976 /// @param tokenId The NFT to transfer977 /// @dev EVM selector for this function is: 0x23b872dd,978 /// or in textual repr: transferFrom(address,address,uint256)979 function transferFrom(980 address from,981 address to,982 uint256 tokenId983 ) public {984 require(false, stub_error);985 from;986 to;987 tokenId;988 dummy = 0;989 }990991 /// @dev Not implemented992 /// @dev EVM selector for this function is: 0x095ea7b3,993 /// or in textual repr: approve(address,uint256)994 function approve(address approved, uint256 tokenId) public {995 require(false, stub_error);996 approved;997 tokenId;998 dummy = 0;999 }10001001 /// @dev Not implemented1002 /// @dev EVM selector for this function is: 0xa22cb465,1003 /// or in textual repr: setApprovalForAll(address,bool)1004 function setApprovalForAll(address operator, bool approved) public {1005 require(false, stub_error);1006 operator;1007 approved;1008 dummy = 0;1009 }10101011 /// @dev Not implemented1012 /// @dev EVM selector for this function is: 0x081812fc,1013 /// or in textual repr: getApproved(uint256)1014 function getApproved(uint256 tokenId) public view returns (address) {1015 require(false, stub_error);1016 tokenId;1017 dummy;1018 return 0x0000000000000000000000000000000000000000;1019 }10201021 /// @dev Not implemented1022 /// @dev EVM selector for this function is: 0xe985e9c5,1023 /// or in textual repr: isApprovedForAll(address,address)1024 function isApprovedForAll(address owner, address operator) public view returns (address) {1025 require(false, stub_error);1026 owner;1027 operator;1028 dummy;1029 return 0x0000000000000000000000000000000000000000;1030 }1031}10321033contract UniqueRefungible is1034 Dummy,1035 ERC165,1036 ERC721,1037 ERC721Enumerable,1038 ERC721UniqueExtensions,1039 ERC721UniqueMintable,1040 ERC721Burnable,1041 ERC721Metadata,1042 Collection,1043 TokenProperties1044{}