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(uint256 tokenId, string memory key, bytes memory value) public {53 // require(false, stub_error);54 // tokenId;55 // key;56 // value;57 // dummy = 0;58 // }5960 /// @notice Set token properties value.61 /// @dev Throws error if `msg.sender` has no permission to edit the property.62 /// @param tokenId ID of the token.63 /// @param properties settable properties64 /// @dev EVM selector for this function is: 0x14ed3a6e,65 /// or in textual repr: setProperties(uint256,(string,bytes)[])66 function setProperties(uint256 tokenId, Property[] memory properties) public {67 require(false, stub_error);68 tokenId;69 properties;70 dummy = 0;71 }7273 // /// @notice Delete token property value.74 // /// @dev Throws error if `msg.sender` has no permission to edit the property.75 // /// @param tokenId ID of the token.76 // /// @param key Property key.77 // /// @dev EVM selector for this function is: 0x066111d1,78 // /// or in textual repr: deleteProperty(uint256,string)79 // function deleteProperty(uint256 tokenId, string memory key) public {80 // require(false, stub_error);81 // tokenId;82 // key;83 // dummy = 0;84 // }8586 /// @notice Delete token properties value.87 /// @dev Throws error if `msg.sender` has no permission to edit the property.88 /// @param tokenId ID of the token.89 /// @param keys Properties key.90 /// @dev EVM selector for this function is: 0xc472d371,91 /// or in textual repr: deleteProperties(uint256,string[])92 function deleteProperties(uint256 tokenId, string[] memory keys) public {93 require(false, stub_error);94 tokenId;95 keys;96 dummy = 0;97 }9899 /// @notice Get token property value.100 /// @dev Throws error if key not found101 /// @param tokenId ID of the token.102 /// @param key Property key.103 /// @return Property value bytes104 /// @dev EVM selector for this function is: 0x7228c327,105 /// or in textual repr: property(uint256,string)106 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107 require(false, stub_error);108 tokenId;109 key;110 dummy;111 return hex"";112 }113}114115/// @dev Property struct116struct Property {117 string key;118 bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0xcc1d80ca123contract Collection is Dummy, ERC165 {124 // /// Set collection property.125 // ///126 // /// @param key Property key.127 // /// @param value Propery value.128 // /// @dev EVM selector for this function is: 0x2f073f66,129 // /// or in textual repr: setCollectionProperty(string,bytes)130 // function setCollectionProperty(string memory key, bytes memory value) public {131 // require(false, stub_error);132 // key;133 // value;134 // dummy = 0;135 // }136137 /// Set collection properties.138 ///139 /// @param properties Vector of properties key/value pair.140 /// @dev EVM selector for this function is: 0x50b26b2a,141 /// or in textual repr: setCollectionProperties((string,bytes)[])142 function setCollectionProperties(Property[] memory properties) public {143 require(false, stub_error);144 properties;145 dummy = 0;146 }147148 // /// Delete collection property.149 // ///150 // /// @param key Property key.151 // /// @dev EVM selector for this function is: 0x7b7debce,152 // /// or in textual repr: deleteCollectionProperty(string)153 // function deleteCollectionProperty(string memory key) public {154 // require(false, stub_error);155 // key;156 // dummy = 0;157 // }158159 /// Delete collection properties.160 ///161 /// @param keys Properties keys.162 /// @dev EVM selector for this function is: 0xee206ee3,163 /// or in textual repr: deleteCollectionProperties(string[])164 function deleteCollectionProperties(string[] memory keys) public {165 require(false, stub_error);166 keys;167 dummy = 0;168 }169170 /// Get collection property.171 ///172 /// @dev Throws error if key not found.173 ///174 /// @param key Property key.175 /// @return bytes The property corresponding to the key.176 /// @dev EVM selector for this function is: 0xcf24fd6d,177 /// or in textual repr: collectionProperty(string)178 function collectionProperty(string memory key) public view returns (bytes memory) {179 require(false, stub_error);180 key;181 dummy;182 return hex"";183 }184185 /// Get collection properties.186 ///187 /// @param keys Properties keys. Empty keys for all propertyes.188 /// @return Vector of properties key/value pairs.189 /// @dev EVM selector for this function is: 0x285fb8e6,190 /// or in textual repr: collectionProperties(string[])191 function collectionProperties(string[] memory keys) public view returns (Property[] memory) {192 require(false, stub_error);193 keys;194 dummy;195 return new Property[](0);196 }197198 // /// Set the sponsor of the collection.199 // ///200 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201 // ///202 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203 // /// @dev EVM selector for this function is: 0x7623402e,204 // /// or in textual repr: setCollectionSponsor(address)205 // function setCollectionSponsor(address sponsor) public {206 // require(false, stub_error);207 // sponsor;208 // dummy = 0;209 // }210211 /// Set the sponsor of the collection.212 ///213 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214 ///215 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216 /// @dev EVM selector for this function is: 0x84a1d5a8,217 /// or in textual repr: setCollectionSponsorCross((address,uint256))218 function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219 require(false, stub_error);220 sponsor;221 dummy = 0;222 }223224 /// Whether there is a pending sponsor.225 /// @dev EVM selector for this function is: 0x058ac185,226 /// or in textual repr: hasCollectionPendingSponsor()227 function hasCollectionPendingSponsor() public view returns (bool) {228 require(false, stub_error);229 dummy;230 return false;231 }232233 /// Collection sponsorship confirmation.234 ///235 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.236 /// @dev EVM selector for this function is: 0x3c50e97a,237 /// or in textual repr: confirmCollectionSponsorship()238 function confirmCollectionSponsorship() public {239 require(false, stub_error);240 dummy = 0;241 }242243 /// Remove collection sponsor.244 /// @dev EVM selector for this function is: 0x6e0326a3,245 /// or in textual repr: removeCollectionSponsor()246 function removeCollectionSponsor() public {247 require(false, stub_error);248 dummy = 0;249 }250251 /// Get current sponsor.252 ///253 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254 /// @dev EVM selector for this function is: 0x6ec0a9f1,255 /// or in textual repr: collectionSponsor()256 function collectionSponsor() public view returns (Tuple29 memory) {257 require(false, stub_error);258 dummy;259 return Tuple29(0x0000000000000000000000000000000000000000, 0);260 }261262 /// Set limits for the collection.263 /// @dev Throws error if limit not found.264 /// @param limit Name of the limit. Valid names:265 /// "accountTokenOwnershipLimit",266 /// "sponsoredDataSize",267 /// "sponsoredDataRateLimit",268 /// "tokenLimit",269 /// "sponsorTransferTimeout",270 /// "sponsorApproveTimeout"271 /// "ownerCanTransfer",272 /// "ownerCanDestroy",273 /// "transfersEnabled"274 /// @param value Value of the limit.275 /// @dev EVM selector for this function is: 0x4ad890a8,276 /// or in textual repr: setCollectionLimit(string,uint256)277 function setCollectionLimit(string memory limit, uint256 value) public {278 require(false, stub_error);279 limit;280 value;281 dummy = 0;282 }283284 /// Get contract address.285 /// @dev EVM selector for this function is: 0xf6b4dfb4,286 /// or in textual repr: contractAddress()287 function contractAddress() public view returns (address) {288 require(false, stub_error);289 dummy;290 return 0x0000000000000000000000000000000000000000;291 }292293 /// Add collection admin.294 /// @param newAdmin Cross account administrator address.295 /// @dev EVM selector for this function is: 0x859aa7d6,296 /// or in textual repr: addCollectionAdminCross((address,uint256))297 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {298 require(false, stub_error);299 newAdmin;300 dummy = 0;301 }302303 /// Remove collection admin.304 /// @param admin Cross account administrator address.305 /// @dev EVM selector for this function is: 0x6c0cd173,306 /// or in textual repr: removeCollectionAdminCross((address,uint256))307 function removeCollectionAdminCross(EthCrossAccount memory admin) public {308 require(false, stub_error);309 admin;310 dummy = 0;311 }312313 // /// Add collection admin.314 // /// @param newAdmin Address of the added administrator.315 // /// @dev EVM selector for this function is: 0x92e462c7,316 // /// or in textual repr: addCollectionAdmin(address)317 // function addCollectionAdmin(address newAdmin) public {318 // require(false, stub_error);319 // newAdmin;320 // dummy = 0;321 // }322323 // /// Remove collection admin.324 // ///325 // /// @param admin Address of the removed administrator.326 // /// @dev EVM selector for this function is: 0xfafd7b42,327 // /// or in textual repr: removeCollectionAdmin(address)328 // function removeCollectionAdmin(address admin) public {329 // require(false, stub_error);330 // admin;331 // dummy = 0;332 // }333334 /// Toggle accessibility of collection nesting.335 ///336 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'337 /// @dev EVM selector for this function is: 0x112d4586,338 /// or in textual repr: setCollectionNesting(bool)339 function setCollectionNesting(bool enable) public {340 require(false, stub_error);341 enable;342 dummy = 0;343 }344345 /// Toggle accessibility of collection nesting.346 ///347 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'348 /// @param collections Addresses of collections that will be available for nesting.349 /// @dev EVM selector for this function is: 0x64872396,350 /// or in textual repr: setCollectionNesting(bool,address[])351 function setCollectionNesting(bool enable, address[] memory collections) public {352 require(false, stub_error);353 enable;354 collections;355 dummy = 0;356 }357358 /// Set the collection access method.359 /// @param mode Access mode360 /// 0 for Normal361 /// 1 for AllowList362 /// @dev EVM selector for this function is: 0x41835d4c,363 /// or in textual repr: setCollectionAccess(uint8)364 function setCollectionAccess(uint8 mode) public {365 require(false, stub_error);366 mode;367 dummy = 0;368 }369370 /// Checks that user allowed to operate with collection.371 ///372 /// @param user User address to check.373 /// @dev EVM selector for this function is: 0x91b6df49,374 /// or in textual repr: allowlistedCross((address,uint256))375 function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {376 require(false, stub_error);377 user;378 dummy;379 return false;380 }381382 // /// Add the user to the allowed list.383 // ///384 // /// @param user Address of a trusted user.385 // /// @dev EVM selector for this function is: 0x67844fe6,386 // /// or in textual repr: addToCollectionAllowList(address)387 // function addToCollectionAllowList(address user) public {388 // require(false, stub_error);389 // user;390 // dummy = 0;391 // }392393 /// Add user to allowed list.394 ///395 /// @param user User cross account address.396 /// @dev EVM selector for this function is: 0xa0184a3a,397 /// or in textual repr: addToCollectionAllowListCross((address,uint256))398 function addToCollectionAllowListCross(EthCrossAccount memory user) public {399 require(false, stub_error);400 user;401 dummy = 0;402 }403404 // /// Remove the user from the allowed list.405 // ///406 // /// @param user Address of a removed user.407 // /// @dev EVM selector for this function is: 0x85c51acb,408 // /// or in textual repr: removeFromCollectionAllowList(address)409 // function removeFromCollectionAllowList(address user) public {410 // require(false, stub_error);411 // user;412 // dummy = 0;413 // }414415 /// Remove user from allowed list.416 ///417 /// @param user User cross account address.418 /// @dev EVM selector for this function is: 0x09ba452a,419 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))420 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {421 require(false, stub_error);422 user;423 dummy = 0;424 }425426 /// Switch permission for minting.427 ///428 /// @param mode Enable if "true".429 /// @dev EVM selector for this function is: 0x00018e84,430 /// or in textual repr: setCollectionMintMode(bool)431 function setCollectionMintMode(bool mode) public {432 require(false, stub_error);433 mode;434 dummy = 0;435 }436437 // /// Check that account is the owner or admin of the collection438 // ///439 // /// @param user account to verify440 // /// @return "true" if account is the owner or admin441 // /// @dev EVM selector for this function is: 0x9811b0c7,442 // /// or in textual repr: isOwnerOrAdmin(address)443 // function isOwnerOrAdmin(address user) public view returns (bool) {444 // require(false, stub_error);445 // user;446 // dummy;447 // return false;448 // }449450 /// Check that account is the owner or admin of the collection451 ///452 /// @param user User cross account to verify453 /// @return "true" if account is the owner or admin454 /// @dev EVM selector for this function is: 0x3e75a905,455 /// or in textual repr: isOwnerOrAdminCross((address,uint256))456 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {457 require(false, stub_error);458 user;459 dummy;460 return false;461 }462463 /// Returns collection type464 ///465 /// @return `Fungible` or `NFT` or `ReFungible`466 /// @dev EVM selector for this function is: 0xd34b55b8,467 /// or in textual repr: uniqueCollectionType()468 function uniqueCollectionType() public view returns (string memory) {469 require(false, stub_error);470 dummy;471 return "";472 }473474 /// Get collection owner.475 ///476 /// @return Tuble with sponsor address and his substrate mirror.477 /// If address is canonical then substrate mirror is zero and vice versa.478 /// @dev EVM selector for this function is: 0xdf727d3b,479 /// or in textual repr: collectionOwner()480 function collectionOwner() public view returns (EthCrossAccount memory) {481 require(false, stub_error);482 dummy;483 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);484 }485486 // /// Changes collection owner to another account487 // ///488 // /// @dev Owner can be changed only by current owner489 // /// @param newOwner new owner account490 // /// @dev EVM selector for this function is: 0x4f53e226,491 // /// or in textual repr: changeCollectionOwner(address)492 // function changeCollectionOwner(address newOwner) public {493 // require(false, stub_error);494 // newOwner;495 // dummy = 0;496 // }497498 /// Get collection administrators499 ///500 /// @return Vector of tuples with admins address and his substrate mirror.501 /// If address is canonical then substrate mirror is zero and vice versa.502 /// @dev EVM selector for this function is: 0x5813216b,503 /// or in textual repr: collectionAdmins()504 function collectionAdmins() public view returns (EthCrossAccount[] memory) {505 require(false, stub_error);506 dummy;507 return new EthCrossAccount[](0);508 }509510 /// Changes collection owner to another account511 ///512 /// @dev Owner can be changed only by current owner513 /// @param newOwner new owner cross account514 /// @dev EVM selector for this function is: 0x6496c497,515 /// or in textual repr: changeCollectionOwnerCross((address,uint256))516 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {517 require(false, stub_error);518 newOwner;519 dummy = 0;520 }521}522523/// @dev Cross account struct524struct EthCrossAccount {525 address eth;526 uint256 sub;527}528529/// @dev anonymous struct530struct Tuple29 {531 address field_0;532 uint256 field_1;533}534535/// @dev the ERC-165 identifier for this interface is 0x5b5e139f536contract ERC721Metadata is Dummy, ERC165 {537 // /// @notice A descriptive name for a collection of NFTs in this contract538 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`539 // /// @dev EVM selector for this function is: 0x06fdde03,540 // /// or in textual repr: name()541 // function name() public view returns (string memory) {542 // require(false, stub_error);543 // dummy;544 // return "";545 // }546547 // /// @notice An abbreviated name for NFTs in this contract548 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`549 // /// @dev EVM selector for this function is: 0x95d89b41,550 // /// or in textual repr: symbol()551 // function symbol() public view returns (string memory) {552 // require(false, stub_error);553 // dummy;554 // return "";555 // }556557 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.558 ///559 /// @dev If the token has a `url` property and it is not empty, it is returned.560 /// 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`.561 /// If the collection property `baseURI` is empty or absent, return "" (empty string)562 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix563 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).564 ///565 /// @return token's const_metadata566 /// @dev EVM selector for this function is: 0xc87b56dd,567 /// or in textual repr: tokenURI(uint256)568 function tokenURI(uint256 tokenId) public view returns (string memory) {569 require(false, stub_error);570 tokenId;571 dummy;572 return "";573 }574}575576/// @title ERC721 Token that can be irreversibly burned (destroyed).577/// @dev the ERC-165 identifier for this interface is 0x42966c68578contract ERC721Burnable is Dummy, ERC165 {579 /// @notice Burns a specific ERC721 token.580 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized581 /// operator of the current owner.582 /// @param tokenId The RFT to approve583 /// @dev EVM selector for this function is: 0x42966c68,584 /// or in textual repr: burn(uint256)585 function burn(uint256 tokenId) public {586 require(false, stub_error);587 tokenId;588 dummy = 0;589 }590}591592/// @dev inlined interface593contract ERC721UniqueMintableEvents {594 event MintingFinished();595}596597/// @title ERC721 minting logic.598/// @dev the ERC-165 identifier for this interface is 0x476ff149599contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {600 /// @dev EVM selector for this function is: 0x05d2035b,601 /// or in textual repr: mintingFinished()602 function mintingFinished() public view returns (bool) {603 require(false, stub_error);604 dummy;605 return false;606 }607608 /// @notice Function to mint token.609 /// @param to The new owner610 /// @return uint256 The id of the newly minted token611 /// @dev EVM selector for this function is: 0x6a627842,612 /// or in textual repr: mint(address)613 function mint(address to) public returns (uint256) {614 require(false, stub_error);615 to;616 dummy = 0;617 return 0;618 }619620 // /// @notice Function to mint token.621 // /// @dev `tokenId` should be obtained with `nextTokenId` method,622 // /// unlike standard, you can't specify it manually623 // /// @param to The new owner624 // /// @param tokenId ID of the minted RFT625 // /// @dev EVM selector for this function is: 0x40c10f19,626 // /// or in textual repr: mint(address,uint256)627 // function mint(address to, uint256 tokenId) public returns (bool) {628 // require(false, stub_error);629 // to;630 // tokenId;631 // dummy = 0;632 // return false;633 // }634635 /// @notice Function to mint token with the given tokenUri.636 /// @param to The new owner637 /// @param tokenUri Token URI that would be stored in the NFT properties638 /// @return uint256 The id of the newly minted token639 /// @dev EVM selector for this function is: 0x45c17782,640 /// or in textual repr: mintWithTokenURI(address,string)641 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {642 require(false, stub_error);643 to;644 tokenUri;645 dummy = 0;646 return 0;647 }648649 // /// @notice Function to mint token with the given tokenUri.650 // /// @dev `tokenId` should be obtained with `nextTokenId` method,651 // /// unlike standard, you can't specify it manually652 // /// @param to The new owner653 // /// @param tokenId ID of the minted RFT654 // /// @param tokenUri Token URI that would be stored in the RFT properties655 // /// @dev EVM selector for this function is: 0x50bb4e7f,656 // /// or in textual repr: mintWithTokenURI(address,uint256,string)657 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {658 // require(false, stub_error);659 // to;660 // tokenId;661 // tokenUri;662 // dummy = 0;663 // return false;664 // }665666 /// @dev Not implemented667 /// @dev EVM selector for this function is: 0x7d64bcb4,668 /// or in textual repr: finishMinting()669 function finishMinting() public returns (bool) {670 require(false, stub_error);671 dummy = 0;672 return false;673 }674}675676/// @title Unique extensions for ERC721.677/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1678contract ERC721UniqueExtensions is Dummy, ERC165 {679 /// @notice A descriptive name for a collection of NFTs in this contract680 /// @dev EVM selector for this function is: 0x06fdde03,681 /// or in textual repr: name()682 function name() public view returns (string memory) {683 require(false, stub_error);684 dummy;685 return "";686 }687688 /// @notice An abbreviated name for NFTs in this contract689 /// @dev EVM selector for this function is: 0x95d89b41,690 /// or in textual repr: symbol()691 function symbol() public view returns (string memory) {692 require(false, stub_error);693 dummy;694 return "";695 }696697 /// @notice A description for the collection.698 /// @dev EVM selector for this function is: 0x7284e416,699 /// or in textual repr: description()700 function description() public view returns (string memory) {701 require(false, stub_error);702 dummy;703 return "";704 }705706 /// Returns the owner (in cross format) of the token.707 ///708 /// @param tokenId Id for the token.709 /// @dev EVM selector for this function is: 0x2b29dace,710 /// or in textual repr: crossOwnerOf(uint256)711 function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {712 require(false, stub_error);713 tokenId;714 dummy;715 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);716 }717718 /// Returns the token properties.719 ///720 /// @param tokenId Id for the token.721 /// @param keys Properties keys. Empty keys for all propertyes.722 /// @return Vector of properties key/value pairs.723 /// @dev EVM selector for this function is: 0xe07ede7e,724 /// or in textual repr: properties(uint256,string[])725 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {726 require(false, stub_error);727 tokenId;728 keys;729 dummy;730 return new Property[](0);731 }732733 /// @notice Transfer ownership of an RFT734 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`735 /// is the zero address. Throws if `tokenId` is not a valid RFT.736 /// Throws if RFT pieces have multiple owners.737 /// @param to The new owner738 /// @param tokenId The RFT to transfer739 /// @dev EVM selector for this function is: 0xa9059cbb,740 /// or in textual repr: transfer(address,uint256)741 function transfer(address to, uint256 tokenId) public {742 require(false, stub_error);743 to;744 tokenId;745 dummy = 0;746 }747748 /// @notice Transfer ownership of an RFT749 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`750 /// is the zero address. Throws if `tokenId` is not a valid RFT.751 /// Throws if RFT pieces have multiple owners.752 /// @param to The new owner753 /// @param tokenId The RFT to transfer754 /// @dev EVM selector for this function is: 0x2ada85ff,755 /// or in textual repr: transferCross((address,uint256),uint256)756 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {757 require(false, stub_error);758 to;759 tokenId;760 dummy = 0;761 }762763 /// @notice Transfer ownership of an RFT764 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`765 /// is the zero address. Throws if `tokenId` is not a valid RFT.766 /// Throws if RFT pieces have multiple owners.767 /// @param to The new owner768 /// @param tokenId The RFT to transfer769 /// @dev EVM selector for this function is: 0xd5cf430b,770 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)771 function transferFromCross(772 EthCrossAccount memory from,773 EthCrossAccount memory to,774 uint256 tokenId775 ) public {776 require(false, stub_error);777 from;778 to;779 tokenId;780 dummy = 0;781 }782783 // /// @notice Burns a specific ERC721 token.784 // /// @dev Throws unless `msg.sender` is the current owner or an authorized785 // /// operator for this RFT. Throws if `from` is not the current owner. Throws786 // /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.787 // /// Throws if RFT pieces have multiple owners.788 // /// @param from The current owner of the RFT789 // /// @param tokenId The RFT to transfer790 // /// @dev EVM selector for this function is: 0x79cc6790,791 // /// or in textual repr: burnFrom(address,uint256)792 // function burnFrom(address from, uint256 tokenId) public {793 // require(false, stub_error);794 // from;795 // tokenId;796 // dummy = 0;797 // }798799 /// @notice Burns a specific ERC721 token.800 /// @dev Throws unless `msg.sender` is the current owner or an authorized801 /// operator for this RFT. Throws if `from` is not the current owner. Throws802 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.803 /// Throws if RFT pieces have multiple owners.804 /// @param from The current owner of the RFT805 /// @param tokenId The RFT to transfer806 /// @dev EVM selector for this function is: 0xbb2f5a58,807 /// or in textual repr: burnFromCross((address,uint256),uint256)808 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {809 require(false, stub_error);810 from;811 tokenId;812 dummy = 0;813 }814815 /// @notice Returns next free RFT ID.816 /// @dev EVM selector for this function is: 0x75794a3c,817 /// or in textual repr: nextTokenId()818 function nextTokenId() public view returns (uint256) {819 require(false, stub_error);820 dummy;821 return 0;822 }823824 // /// @notice Function to mint multiple tokens.825 // /// @dev `tokenIds` should be an array of consecutive numbers and first number826 // /// should be obtained with `nextTokenId` method827 // /// @param to The new owner828 // /// @param tokenIds IDs of the minted RFTs829 // /// @dev EVM selector for this function is: 0x44a9945e,830 // /// or in textual repr: mintBulk(address,uint256[])831 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {832 // require(false, stub_error);833 // to;834 // tokenIds;835 // dummy = 0;836 // return false;837 // }838839 // /// @notice Function to mint multiple tokens with the given tokenUris.840 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive841 // /// numbers and first number should be obtained with `nextTokenId` method842 // /// @param to The new owner843 // /// @param tokens array of pairs of token ID and token URI for minted tokens844 // /// @dev EVM selector for this function is: 0x36543006,845 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])846 // function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {847 // require(false, stub_error);848 // to;849 // tokens;850 // dummy = 0;851 // return false;852 // }853854 /// Returns EVM address for refungible token855 ///856 /// @param token ID of the token857 /// @dev EVM selector for this function is: 0xab76fac6,858 /// or in textual repr: tokenContractAddress(uint256)859 function tokenContractAddress(uint256 token) public view returns (address) {860 require(false, stub_error);861 token;862 dummy;863 return 0x0000000000000000000000000000000000000000;864 }865}866867/// @dev anonymous struct868struct Tuple14 {869 uint256 field_0;870 string field_1;871}872873/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension874/// @dev See https://eips.ethereum.org/EIPS/eip-721875/// @dev the ERC-165 identifier for this interface is 0x780e9d63876contract ERC721Enumerable is Dummy, ERC165 {877 /// @notice Enumerate valid RFTs878 /// @param index A counter less than `totalSupply()`879 /// @return The token identifier for the `index`th NFT,880 /// (sort order not specified)881 /// @dev EVM selector for this function is: 0x4f6ccce7,882 /// or in textual repr: tokenByIndex(uint256)883 function tokenByIndex(uint256 index) public view returns (uint256) {884 require(false, stub_error);885 index;886 dummy;887 return 0;888 }889890 /// Not implemented891 /// @dev EVM selector for this function is: 0x2f745c59,892 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)893 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {894 require(false, stub_error);895 owner;896 index;897 dummy;898 return 0;899 }900901 /// @notice Count RFTs tracked by this contract902 /// @return A count of valid RFTs tracked by this contract, where each one of903 /// them has an assigned and queryable owner not equal to the zero address904 /// @dev EVM selector for this function is: 0x18160ddd,905 /// or in textual repr: totalSupply()906 function totalSupply() public view returns (uint256) {907 require(false, stub_error);908 dummy;909 return 0;910 }911}912913/// @dev inlined interface914contract ERC721Events {915 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);916 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);917 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);918}919920/// @title ERC-721 Non-Fungible Token Standard921/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md922/// @dev the ERC-165 identifier for this interface is 0x4016cd87923contract ERC721 is Dummy, ERC165, ERC721Events {924 /// @notice Count all RFTs assigned to an owner925 /// @dev RFTs assigned to the zero address are considered invalid, and this926 /// function throws for queries about the zero address.927 /// @param owner An address for whom to query the balance928 /// @return The number of RFTs owned by `owner`, possibly zero929 /// @dev EVM selector for this function is: 0x70a08231,930 /// or in textual repr: balanceOf(address)931 function balanceOf(address owner) public view returns (uint256) {932 require(false, stub_error);933 owner;934 dummy;935 return 0;936 }937938 /// @notice Find the owner of an RFT939 /// @dev RFTs assigned to zero address are considered invalid, and queries940 /// about them do throw.941 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for942 /// the tokens that are partially owned.943 /// @param tokenId The identifier for an RFT944 /// @return The address of the owner of the RFT945 /// @dev EVM selector for this function is: 0x6352211e,946 /// or in textual repr: ownerOf(uint256)947 function ownerOf(uint256 tokenId) public view returns (address) {948 require(false, stub_error);949 tokenId;950 dummy;951 return 0x0000000000000000000000000000000000000000;952 }953954 /// @dev Not implemented955 /// @dev EVM selector for this function is: 0x60a11672,956 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)957 function safeTransferFromWithData(958 address from,959 address to,960 uint256 tokenId,961 bytes memory data962 ) public {963 require(false, stub_error);964 from;965 to;966 tokenId;967 data;968 dummy = 0;969 }970971 /// @dev Not implemented972 /// @dev EVM selector for this function is: 0x42842e0e,973 /// or in textual repr: safeTransferFrom(address,address,uint256)974 function safeTransferFrom(975 address from,976 address to,977 uint256 tokenId978 ) public {979 require(false, stub_error);980 from;981 to;982 tokenId;983 dummy = 0;984 }985986 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE987 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE988 /// THEY MAY BE PERMANENTLY LOST989 /// @dev Throws unless `msg.sender` is the current owner or an authorized990 /// operator for this RFT. Throws if `from` is not the current owner. Throws991 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.992 /// Throws if RFT pieces have multiple owners.993 /// @param from The current owner of the NFT994 /// @param to The new owner995 /// @param tokenId The NFT to transfer996 /// @dev EVM selector for this function is: 0x23b872dd,997 /// or in textual repr: transferFrom(address,address,uint256)998 function transferFrom(999 address from,1000 address to,1001 uint256 tokenId1002 ) public {1003 require(false, stub_error);1004 from;1005 to;1006 tokenId;1007 dummy = 0;1008 }10091010 /// @dev Not implemented1011 /// @dev EVM selector for this function is: 0x095ea7b3,1012 /// or in textual repr: approve(address,uint256)1013 function approve(address approved, uint256 tokenId) public {1014 require(false, stub_error);1015 approved;1016 tokenId;1017 dummy = 0;1018 }10191020 /// @dev Not implemented1021 /// @dev EVM selector for this function is: 0xa22cb465,1022 /// or in textual repr: setApprovalForAll(address,bool)1023 function setApprovalForAll(address operator, bool approved) public {1024 require(false, stub_error);1025 operator;1026 approved;1027 dummy = 0;1028 }10291030 /// @dev Not implemented1031 /// @dev EVM selector for this function is: 0x081812fc,1032 /// or in textual repr: getApproved(uint256)1033 function getApproved(uint256 tokenId) public view returns (address) {1034 require(false, stub_error);1035 tokenId;1036 dummy;1037 return 0x0000000000000000000000000000000000000000;1038 }10391040 /// @dev Not implemented1041 /// @dev EVM selector for this function is: 0xe985e9c5,1042 /// or in textual repr: isApprovedForAll(address,address)1043 function isApprovedForAll(address owner, address operator) public view returns (address) {1044 require(false, stub_error);1045 owner;1046 operator;1047 dummy;1048 return 0x0000000000000000000000000000000000000000;1049 }10501051 /// @notice Returns collection helper contract address1052 /// @dev EVM selector for this function is: 0x1896cce6,1053 /// or in textual repr: collectionHelperAddress()1054 function collectionHelperAddress() public view returns (address) {1055 require(false, stub_error);1056 dummy;1057 return 0x0000000000000000000000000000000000000000;1058 }1059}10601061contract UniqueRefungible is1062 Dummy,1063 ERC165,1064 ERC721,1065 ERC721Enumerable,1066 ERC721UniqueExtensions,1067 ERC721UniqueMintable,1068 ERC721Burnable,1069 ERC721Metadata,1070 Collection,1071 TokenProperties1072{}