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, Tuple20[] 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(Tuple20[] 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 (Tuple20[] memory) {190 require(false, stub_error);191 keys;192 dummy;193 return new Tuple20[](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 (Tuple23 memory) {255 require(false, stub_error);256 dummy;257 return Tuple23(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 Tuple23 {542 address field_0;543 uint256 field_1;544}545546/// @dev anonymous struct547struct Tuple20 {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 0x81feb398695contract 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: 0xd5cf430b,736 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)737 function transferFromCross(738 EthCrossAccount memory from,739 EthCrossAccount memory to,740 uint256 tokenId741 ) public {742 require(false, stub_error);743 from;744 to;745 tokenId;746 dummy = 0;747 }748749 /// @notice Burns a specific ERC721 token.750 /// @dev Throws unless `msg.sender` is the current owner or an authorized751 /// operator for this RFT. Throws if `from` is not the current owner. Throws752 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.753 /// Throws if RFT pieces have multiple owners.754 /// @param from The current owner of the RFT755 /// @param tokenId The RFT to transfer756 /// @dev EVM selector for this function is: 0x79cc6790,757 /// or in textual repr: burnFrom(address,uint256)758 function burnFrom(address from, uint256 tokenId) public {759 require(false, stub_error);760 from;761 tokenId;762 dummy = 0;763 }764765 /// @notice Burns a specific ERC721 token.766 /// @dev Throws unless `msg.sender` is the current owner or an authorized767 /// operator for this RFT. Throws if `from` is not the current owner. Throws768 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.769 /// Throws if RFT pieces have multiple owners.770 /// @param from The current owner of the RFT771 /// @param tokenId The RFT to transfer772 /// @dev EVM selector for this function is: 0xbb2f5a58,773 /// or in textual repr: burnFromCross((address,uint256),uint256)774 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {775 require(false, stub_error);776 from;777 tokenId;778 dummy = 0;779 }780781 /// @notice Returns next free RFT ID.782 /// @dev EVM selector for this function is: 0x75794a3c,783 /// or in textual repr: nextTokenId()784 function nextTokenId() public view returns (uint256) {785 require(false, stub_error);786 dummy;787 return 0;788 }789790 // /// @notice Function to mint multiple tokens.791 // /// @dev `tokenIds` should be an array of consecutive numbers and first number792 // /// should be obtained with `nextTokenId` method793 // /// @param to The new owner794 // /// @param tokenIds IDs of the minted RFTs795 // /// @dev EVM selector for this function is: 0x44a9945e,796 // /// or in textual repr: mintBulk(address,uint256[])797 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {798 // require(false, stub_error);799 // to;800 // tokenIds;801 // dummy = 0;802 // return false;803 // }804805 // /// @notice Function to mint multiple tokens with the given tokenUris.806 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive807 // /// numbers and first number should be obtained with `nextTokenId` method808 // /// @param to The new owner809 // /// @param tokens array of pairs of token ID and token URI for minted tokens810 // /// @dev EVM selector for this function is: 0x36543006,811 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])812 // function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) public returns (bool) {813 // require(false, stub_error);814 // to;815 // tokens;816 // dummy = 0;817 // return false;818 // }819820 /// Returns EVM address for refungible token821 ///822 /// @param token ID of the token823 /// @dev EVM selector for this function is: 0xab76fac6,824 /// or in textual repr: tokenContractAddress(uint256)825 function tokenContractAddress(uint256 token) public view returns (address) {826 require(false, stub_error);827 token;828 dummy;829 return 0x0000000000000000000000000000000000000000;830 }831}832833/// @dev anonymous struct834struct Tuple9 {835 uint256 field_0;836 string field_1;837}838839/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension840/// @dev See https://eips.ethereum.org/EIPS/eip-721841/// @dev the ERC-165 identifier for this interface is 0x780e9d63842contract ERC721Enumerable is Dummy, ERC165 {843 /// @notice Enumerate valid RFTs844 /// @param index A counter less than `totalSupply()`845 /// @return The token identifier for the `index`th NFT,846 /// (sort order not specified)847 /// @dev EVM selector for this function is: 0x4f6ccce7,848 /// or in textual repr: tokenByIndex(uint256)849 function tokenByIndex(uint256 index) public view returns (uint256) {850 require(false, stub_error);851 index;852 dummy;853 return 0;854 }855856 /// Not implemented857 /// @dev EVM selector for this function is: 0x2f745c59,858 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)859 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {860 require(false, stub_error);861 owner;862 index;863 dummy;864 return 0;865 }866867 /// @notice Count RFTs tracked by this contract868 /// @return A count of valid RFTs tracked by this contract, where each one of869 /// them has an assigned and queryable owner not equal to the zero address870 /// @dev EVM selector for this function is: 0x18160ddd,871 /// or in textual repr: totalSupply()872 function totalSupply() public view returns (uint256) {873 require(false, stub_error);874 dummy;875 return 0;876 }877}878879/// @dev inlined interface880contract ERC721Events {881 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);882 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);883 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);884}885886/// @title ERC-721 Non-Fungible Token Standard887/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md888/// @dev the ERC-165 identifier for this interface is 0x58800161889contract ERC721 is Dummy, ERC165, ERC721Events {890 /// @notice Count all RFTs assigned to an owner891 /// @dev RFTs assigned to the zero address are considered invalid, and this892 /// function throws for queries about the zero address.893 /// @param owner An address for whom to query the balance894 /// @return The number of RFTs owned by `owner`, possibly zero895 /// @dev EVM selector for this function is: 0x70a08231,896 /// or in textual repr: balanceOf(address)897 function balanceOf(address owner) public view returns (uint256) {898 require(false, stub_error);899 owner;900 dummy;901 return 0;902 }903904 /// @notice Find the owner of an RFT905 /// @dev RFTs assigned to zero address are considered invalid, and queries906 /// about them do throw.907 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for908 /// the tokens that are partially owned.909 /// @param tokenId The identifier for an RFT910 /// @return The address of the owner of the RFT911 /// @dev EVM selector for this function is: 0x6352211e,912 /// or in textual repr: ownerOf(uint256)913 function ownerOf(uint256 tokenId) public view returns (address) {914 require(false, stub_error);915 tokenId;916 dummy;917 return 0x0000000000000000000000000000000000000000;918 }919920 /// @dev Not implemented921 /// @dev EVM selector for this function is: 0x60a11672,922 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)923 function safeTransferFromWithData(924 address from,925 address to,926 uint256 tokenId,927 bytes memory data928 ) public {929 require(false, stub_error);930 from;931 to;932 tokenId;933 data;934 dummy = 0;935 }936937 /// @dev Not implemented938 /// @dev EVM selector for this function is: 0x42842e0e,939 /// or in textual repr: safeTransferFrom(address,address,uint256)940 function safeTransferFrom(941 address from,942 address to,943 uint256 tokenId944 ) public {945 require(false, stub_error);946 from;947 to;948 tokenId;949 dummy = 0;950 }951952 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE953 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE954 /// THEY MAY BE PERMANENTLY LOST955 /// @dev Throws unless `msg.sender` is the current owner or an authorized956 /// operator for this RFT. Throws if `from` is not the current owner. Throws957 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.958 /// Throws if RFT pieces have multiple owners.959 /// @param from The current owner of the NFT960 /// @param to The new owner961 /// @param tokenId The NFT to transfer962 /// @dev EVM selector for this function is: 0x23b872dd,963 /// or in textual repr: transferFrom(address,address,uint256)964 function transferFrom(965 address from,966 address to,967 uint256 tokenId968 ) public {969 require(false, stub_error);970 from;971 to;972 tokenId;973 dummy = 0;974 }975976 /// @dev Not implemented977 /// @dev EVM selector for this function is: 0x095ea7b3,978 /// or in textual repr: approve(address,uint256)979 function approve(address approved, uint256 tokenId) public {980 require(false, stub_error);981 approved;982 tokenId;983 dummy = 0;984 }985986 /// @dev Not implemented987 /// @dev EVM selector for this function is: 0xa22cb465,988 /// or in textual repr: setApprovalForAll(address,bool)989 function setApprovalForAll(address operator, bool approved) public {990 require(false, stub_error);991 operator;992 approved;993 dummy = 0;994 }995996 /// @dev Not implemented997 /// @dev EVM selector for this function is: 0x081812fc,998 /// or in textual repr: getApproved(uint256)999 function getApproved(uint256 tokenId) public view returns (address) {1000 require(false, stub_error);1001 tokenId;1002 dummy;1003 return 0x0000000000000000000000000000000000000000;1004 }10051006 /// @dev Not implemented1007 /// @dev EVM selector for this function is: 0xe985e9c5,1008 /// or in textual repr: isApprovedForAll(address,address)1009 function isApprovedForAll(address owner, address operator) public view returns (address) {1010 require(false, stub_error);1011 owner;1012 operator;1013 dummy;1014 return 0x0000000000000000000000000000000000000000;1015 }1016}10171018contract UniqueRefungible is1019 Dummy,1020 ERC165,1021 ERC721,1022 ERC721Enumerable,1023 ERC721UniqueExtensions,1024 ERC721UniqueMintable,1025 ERC721Burnable,1026 ERC721Metadata,1027 Collection,1028 TokenProperties1029{}