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)14 external15 view16 returns (bool)17 {18 require(false, stub_error);19 interfaceID;20 return true;21 }22}2324/// @title A contract that allows to set and delete token properties and change token property permissions.25/// @dev the ERC-165 identifier for this interface is 0x4136937726contract TokenProperties is Dummy, ERC165 {27 /// @notice Set permissions for token property.28 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.29 /// @param key Property key.30 /// @param isMutable Permission to mutate property.31 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.32 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.33 /// @dev EVM selector for this function is: 0x222d97fa,34 /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)35 function setTokenPropertyPermission(36 string memory key,37 bool isMutable,38 bool collectionAdmin,39 bool tokenOwner40 ) public {41 require(false, stub_error);42 key;43 isMutable;44 collectionAdmin;45 tokenOwner;46 dummy = 0;47 }4849 /// @notice Set token property value.50 /// @dev Throws error if `msg.sender` has no permission to edit the property.51 /// @param tokenId ID of the token.52 /// @param key Property key.53 /// @param value Property value.54 /// @dev EVM selector for this function is: 0x1752d67b,55 /// or in textual repr: setProperty(uint256,string,bytes)56 function setProperty(57 uint256 tokenId,58 string memory key,59 bytes memory value60 ) public {61 require(false, stub_error);62 tokenId;63 key;64 value;65 dummy = 0;66 }6768 /// @notice Delete token property value.69 /// @dev Throws error if `msg.sender` has no permission to edit the property.70 /// @param tokenId ID of the token.71 /// @param key Property key.72 /// @dev EVM selector for this function is: 0x066111d1,73 /// or in textual repr: deleteProperty(uint256,string)74 function deleteProperty(uint256 tokenId, string memory key) public {75 require(false, stub_error);76 tokenId;77 key;78 dummy = 0;79 }8081 /// @notice Get token property value.82 /// @dev Throws error if key not found83 /// @param tokenId ID of the token.84 /// @param key Property key.85 /// @return Property value bytes86 /// @dev EVM selector for this function is: 0x7228c327,87 /// or in textual repr: property(uint256,string)88 function property(uint256 tokenId, string memory key)89 public90 view91 returns (bytes memory)92 {93 require(false, stub_error);94 tokenId;95 key;96 dummy;97 return hex"";98 }99}100101/// @title A contract that allows you to work with collections.102/// @dev the ERC-165 identifier for this interface is 0xe54be640103contract Collection is Dummy, ERC165 {104 /// Set collection property.105 ///106 /// @param key Property key.107 /// @param value Propery value.108 /// @dev EVM selector for this function is: 0x2f073f66,109 /// or in textual repr: setCollectionProperty(string,bytes)110 function setCollectionProperty(string memory key, bytes memory value)111 public112 {113 require(false, stub_error);114 key;115 value;116 dummy = 0;117 }118119 /// Delete collection property.120 ///121 /// @param key Property key.122 /// @dev EVM selector for this function is: 0x7b7debce,123 /// or in textual repr: deleteCollectionProperty(string)124 function deleteCollectionProperty(string memory key) public {125 require(false, stub_error);126 key;127 dummy = 0;128 }129130 /// Get collection property.131 ///132 /// @dev Throws error if key not found.133 ///134 /// @param key Property key.135 /// @return bytes The property corresponding to the key.136 /// @dev EVM selector for this function is: 0xcf24fd6d,137 /// or in textual repr: collectionProperty(string)138 function collectionProperty(string memory key)139 public140 view141 returns (bytes memory)142 {143 require(false, stub_error);144 key;145 dummy;146 return hex"";147 }148149 /// Set the sponsor of the collection.150 ///151 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.152 ///153 /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.154 /// @dev EVM selector for this function is: 0x7623402e,155 /// or in textual repr: setCollectionSponsor(address)156 function setCollectionSponsor(address sponsor) public {157 require(false, stub_error);158 sponsor;159 dummy = 0;160 }161162 /// Set the substrate sponsor of the collection.163 ///164 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.165 ///166 /// @param sponsor Substrate address of the sponsor from whose account funds will be debited for operations with the contract.167 /// @dev EVM selector for this function is: 0xc74d6751,168 /// or in textual repr: setCollectionSponsorSubstrate(uint256)169 function setCollectionSponsorSubstrate(uint256 sponsor) public {170 require(false, stub_error);171 sponsor;172 dummy = 0;173 }174175 /// @dev EVM selector for this function is: 0x058ac185,176 /// or in textual repr: hasCollectionPendingSponsor()177 function hasCollectionPendingSponsor() public view returns (bool) {178 require(false, stub_error);179 dummy;180 return false;181 }182183 /// Collection sponsorship confirmation.184 ///185 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.186 /// @dev EVM selector for this function is: 0x3c50e97a,187 /// or in textual repr: confirmCollectionSponsorship()188 function confirmCollectionSponsorship() public {189 require(false, stub_error);190 dummy = 0;191 }192193 /// Remove collection sponsor.194 /// @dev EVM selector for this function is: 0x6e0326a3,195 /// or in textual repr: removeCollectionSponsor()196 function removeCollectionSponsor() public {197 require(false, stub_error);198 dummy = 0;199 }200201 /// Get current sponsor.202 ///203 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.204 /// @dev EVM selector for this function is: 0xb66bbc14,205 /// or in textual repr: getCollectionSponsor()206 function getCollectionSponsor() public view returns (Tuple17 memory) {207 require(false, stub_error);208 dummy;209 return Tuple17(0x0000000000000000000000000000000000000000, 0);210 }211212 /// Set limits for the collection.213 /// @dev Throws error if limit not found.214 /// @param limit Name of the limit. Valid names:215 /// "accountTokenOwnershipLimit",216 /// "sponsoredDataSize",217 /// "sponsoredDataRateLimit",218 /// "tokenLimit",219 /// "sponsorTransferTimeout",220 /// "sponsorApproveTimeout"221 /// @param value Value of the limit.222 /// @dev EVM selector for this function is: 0x6a3841db,223 /// or in textual repr: setCollectionLimit(string,uint32)224 function setCollectionLimit(string memory limit, uint32 value) public {225 require(false, stub_error);226 limit;227 value;228 dummy = 0;229 }230231 /// Set limits for the collection.232 /// @dev Throws error if limit not found.233 /// @param limit Name of the limit. Valid names:234 /// "ownerCanTransfer",235 /// "ownerCanDestroy",236 /// "transfersEnabled"237 /// @param value Value of the limit.238 /// @dev EVM selector for this function is: 0x993b7fba,239 /// or in textual repr: setCollectionLimit(string,bool)240 function setCollectionLimit(string memory limit, bool value) public {241 require(false, stub_error);242 limit;243 value;244 dummy = 0;245 }246247 /// Get contract address.248 /// @dev EVM selector for this function is: 0xf6b4dfb4,249 /// or in textual repr: contractAddress()250 function contractAddress() public view returns (address) {251 require(false, stub_error);252 dummy;253 return 0x0000000000000000000000000000000000000000;254 }255256 /// Add collection admin by substrate address.257 /// @param newAdmin Substrate administrator address.258 /// @dev EVM selector for this function is: 0x5730062b,259 /// or in textual repr: addCollectionAdminSubstrate(uint256)260 function addCollectionAdminSubstrate(uint256 newAdmin) public {261 require(false, stub_error);262 newAdmin;263 dummy = 0;264 }265266 /// Remove collection admin by substrate address.267 /// @param admin Substrate administrator address.268 /// @dev EVM selector for this function is: 0x4048fcf9,269 /// or in textual repr: removeCollectionAdminSubstrate(uint256)270 function removeCollectionAdminSubstrate(uint256 admin) public {271 require(false, stub_error);272 admin;273 dummy = 0;274 }275276 /// Add collection admin.277 /// @param newAdmin Address of the added administrator.278 /// @dev EVM selector for this function is: 0x92e462c7,279 /// or in textual repr: addCollectionAdmin(address)280 function addCollectionAdmin(address newAdmin) public {281 require(false, stub_error);282 newAdmin;283 dummy = 0;284 }285286 /// Remove collection admin.287 ///288 /// @param admin Address of the removed administrator.289 /// @dev EVM selector for this function is: 0xfafd7b42,290 /// or in textual repr: removeCollectionAdmin(address)291 function removeCollectionAdmin(address admin) public {292 require(false, stub_error);293 admin;294 dummy = 0;295 }296297 /// Toggle accessibility of collection nesting.298 ///299 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'300 /// @dev EVM selector for this function is: 0x112d4586,301 /// or in textual repr: setCollectionNesting(bool)302 function setCollectionNesting(bool enable) public {303 require(false, stub_error);304 enable;305 dummy = 0;306 }307308 /// Toggle accessibility of collection nesting.309 ///310 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'311 /// @param collections Addresses of collections that will be available for nesting.312 /// @dev EVM selector for this function is: 0x64872396,313 /// or in textual repr: setCollectionNesting(bool,address[])314 function setCollectionNesting(bool enable, address[] memory collections)315 public316 {317 require(false, stub_error);318 enable;319 collections;320 dummy = 0;321 }322323 /// Set the collection access method.324 /// @param mode Access mode325 /// 0 for Normal326 /// 1 for AllowList327 /// @dev EVM selector for this function is: 0x41835d4c,328 /// or in textual repr: setCollectionAccess(uint8)329 function setCollectionAccess(uint8 mode) public {330 require(false, stub_error);331 mode;332 dummy = 0;333 }334335 /// Add the user to the allowed list.336 ///337 /// @param user Address of a trusted user.338 /// @dev EVM selector for this function is: 0x67844fe6,339 /// or in textual repr: addToCollectionAllowList(address)340 function addToCollectionAllowList(address user) public {341 require(false, stub_error);342 user;343 dummy = 0;344 }345346 /// Remove the user from the allowed list.347 ///348 /// @param user Address of a removed user.349 /// @dev EVM selector for this function is: 0x85c51acb,350 /// or in textual repr: removeFromCollectionAllowList(address)351 function removeFromCollectionAllowList(address user) public {352 require(false, stub_error);353 user;354 dummy = 0;355 }356357 /// Switch permission for minting.358 ///359 /// @param mode Enable if "true".360 /// @dev EVM selector for this function is: 0x00018e84,361 /// or in textual repr: setCollectionMintMode(bool)362 function setCollectionMintMode(bool mode) public {363 require(false, stub_error);364 mode;365 dummy = 0;366 }367368 /// Check that account is the owner or admin of the collection369 ///370 /// @param user account to verify371 /// @return "true" if account is the owner or admin372 /// @dev EVM selector for this function is: 0x9811b0c7,373 /// or in textual repr: isOwnerOrAdmin(address)374 function isOwnerOrAdmin(address user) public view returns (bool) {375 require(false, stub_error);376 user;377 dummy;378 return false;379 }380381 /// Check that substrate account is the owner or admin of the collection382 ///383 /// @param user account to verify384 /// @return "true" if account is the owner or admin385 /// @dev EVM selector for this function is: 0x68910e00,386 /// or in textual repr: isOwnerOrAdminSubstrate(uint256)387 function isOwnerOrAdminSubstrate(uint256 user) public view returns (bool) {388 require(false, stub_error);389 user;390 dummy;391 return false;392 }393394 /// Returns collection type395 ///396 /// @return `Fungible` or `NFT` or `ReFungible`397 /// @dev EVM selector for this function is: 0xd34b55b8,398 /// or in textual repr: uniqueCollectionType()399 function uniqueCollectionType() public returns (string memory) {400 require(false, stub_error);401 dummy = 0;402 return "";403 }404405 /// Changes collection owner to another account406 ///407 /// @dev Owner can be changed only by current owner408 /// @param newOwner new owner account409 /// @dev EVM selector for this function is: 0x13af4035,410 /// or in textual repr: setOwner(address)411 function setOwner(address newOwner) public {412 require(false, stub_error);413 newOwner;414 dummy = 0;415 }416417 /// Changes collection owner to another substrate account418 ///419 /// @dev Owner can be changed only by current owner420 /// @param newOwner new owner substrate account421 /// @dev EVM selector for this function is: 0xb212138f,422 /// or in textual repr: setOwnerSubstrate(uint256)423 function setOwnerSubstrate(uint256 newOwner) public {424 require(false, stub_error);425 newOwner;426 dummy = 0;427 }428}429430/// @dev anonymous struct431struct Tuple17 {432 address field_0;433 uint256 field_1;434}435436/// @title ERC721 Token that can be irreversibly burned (destroyed).437/// @dev the ERC-165 identifier for this interface is 0x42966c68438contract ERC721Burnable is Dummy, ERC165 {439 /// @notice Burns a specific ERC721 token.440 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized441 /// operator of the current owner.442 /// @param tokenId The RFT to approve443 /// @dev EVM selector for this function is: 0x42966c68,444 /// or in textual repr: burn(uint256)445 function burn(uint256 tokenId) public {446 require(false, stub_error);447 tokenId;448 dummy = 0;449 }450}451452/// @dev inlined interface453contract ERC721MintableEvents {454 event MintingFinished();455}456457/// @title ERC721 minting logic.458/// @dev the ERC-165 identifier for this interface is 0x68ccfe89459contract ERC721Mintable is Dummy, ERC165, ERC721MintableEvents {460 /// @dev EVM selector for this function is: 0x05d2035b,461 /// or in textual repr: mintingFinished()462 function mintingFinished() public view returns (bool) {463 require(false, stub_error);464 dummy;465 return false;466 }467468 /// @notice Function to mint token.469 /// @dev `tokenId` should be obtained with `nextTokenId` method,470 /// unlike standard, you can't specify it manually471 /// @param to The new owner472 /// @param tokenId ID of the minted RFT473 /// @dev EVM selector for this function is: 0x40c10f19,474 /// or in textual repr: mint(address,uint256)475 function mint(address to, uint256 tokenId) public returns (bool) {476 require(false, stub_error);477 to;478 tokenId;479 dummy = 0;480 return false;481 }482483 /// @notice Function to mint token with the given tokenUri.484 /// @dev `tokenId` should be obtained with `nextTokenId` method,485 /// unlike standard, you can't specify it manually486 /// @param to The new owner487 /// @param tokenId ID of the minted RFT488 /// @param tokenUri Token URI that would be stored in the RFT properties489 /// @dev EVM selector for this function is: 0x50bb4e7f,490 /// or in textual repr: mintWithTokenURI(address,uint256,string)491 function mintWithTokenURI(492 address to,493 uint256 tokenId,494 string memory tokenUri495 ) public returns (bool) {496 require(false, stub_error);497 to;498 tokenId;499 tokenUri;500 dummy = 0;501 return false;502 }503504 /// @dev Not implemented505 /// @dev EVM selector for this function is: 0x7d64bcb4,506 /// or in textual repr: finishMinting()507 function finishMinting() public returns (bool) {508 require(false, stub_error);509 dummy = 0;510 return false;511 }512}513514/// @title Unique extensions for ERC721.515/// @dev the ERC-165 identifier for this interface is 0x7c3bef89516contract ERC721UniqueExtensions is Dummy, ERC165 {517 /// @notice Transfer ownership of an RFT518 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`519 /// is the zero address. Throws if `tokenId` is not a valid RFT.520 /// Throws if RFT pieces have multiple owners.521 /// @param to The new owner522 /// @param tokenId The RFT to transfer523 /// @dev EVM selector for this function is: 0xa9059cbb,524 /// or in textual repr: transfer(address,uint256)525 function transfer(address to, uint256 tokenId) public {526 require(false, stub_error);527 to;528 tokenId;529 dummy = 0;530 }531532 /// @notice Burns a specific ERC721 token.533 /// @dev Throws unless `msg.sender` is the current owner or an authorized534 /// operator for this RFT. Throws if `from` is not the current owner. Throws535 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.536 /// Throws if RFT pieces have multiple owners.537 /// @param from The current owner of the RFT538 /// @param tokenId The RFT to transfer539 /// @dev EVM selector for this function is: 0x79cc6790,540 /// or in textual repr: burnFrom(address,uint256)541 function burnFrom(address from, uint256 tokenId) public {542 require(false, stub_error);543 from;544 tokenId;545 dummy = 0;546 }547548 /// @notice Returns next free RFT ID.549 /// @dev EVM selector for this function is: 0x75794a3c,550 /// or in textual repr: nextTokenId()551 function nextTokenId() public view returns (uint256) {552 require(false, stub_error);553 dummy;554 return 0;555 }556557 /// @notice Function to mint multiple tokens.558 /// @dev `tokenIds` should be an array of consecutive numbers and first number559 /// should be obtained with `nextTokenId` method560 /// @param to The new owner561 /// @param tokenIds IDs of the minted RFTs562 /// @dev EVM selector for this function is: 0x44a9945e,563 /// or in textual repr: mintBulk(address,uint256[])564 function mintBulk(address to, uint256[] memory tokenIds)565 public566 returns (bool)567 {568 require(false, stub_error);569 to;570 tokenIds;571 dummy = 0;572 return false;573 }574575 /// @notice Function to mint multiple tokens with the given tokenUris.576 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive577 /// numbers and first number should be obtained with `nextTokenId` method578 /// @param to The new owner579 /// @param tokens array of pairs of token ID and token URI for minted tokens580 /// @dev EVM selector for this function is: 0x36543006,581 /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])582 function mintBulkWithTokenURI(address to, Tuple8[] memory tokens)583 public584 returns (bool)585 {586 require(false, stub_error);587 to;588 tokens;589 dummy = 0;590 return false;591 }592593 /// Returns EVM address for refungible token594 ///595 /// @param token ID of the token596 /// @dev EVM selector for this function is: 0xab76fac6,597 /// or in textual repr: tokenContractAddress(uint256)598 function tokenContractAddress(uint256 token) public view returns (address) {599 require(false, stub_error);600 token;601 dummy;602 return 0x0000000000000000000000000000000000000000;603 }604}605606/// @dev anonymous struct607struct Tuple8 {608 uint256 field_0;609 string field_1;610}611612/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension613/// @dev See https://eips.ethereum.org/EIPS/eip-721614/// @dev the ERC-165 identifier for this interface is 0x780e9d63615contract ERC721Enumerable is Dummy, ERC165 {616 /// @notice Enumerate valid RFTs617 /// @param index A counter less than `totalSupply()`618 /// @return The token identifier for the `index`th NFT,619 /// (sort order not specified)620 /// @dev EVM selector for this function is: 0x4f6ccce7,621 /// or in textual repr: tokenByIndex(uint256)622 function tokenByIndex(uint256 index) public view returns (uint256) {623 require(false, stub_error);624 index;625 dummy;626 return 0;627 }628629 /// Not implemented630 /// @dev EVM selector for this function is: 0x2f745c59,631 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)632 function tokenOfOwnerByIndex(address owner, uint256 index)633 public634 view635 returns (uint256)636 {637 require(false, stub_error);638 owner;639 index;640 dummy;641 return 0;642 }643644 /// @notice Count RFTs tracked by this contract645 /// @return A count of valid RFTs tracked by this contract, where each one of646 /// them has an assigned and queryable owner not equal to the zero address647 /// @dev EVM selector for this function is: 0x18160ddd,648 /// or in textual repr: totalSupply()649 function totalSupply() public view returns (uint256) {650 require(false, stub_error);651 dummy;652 return 0;653 }654}655656/// @dev the ERC-165 identifier for this interface is 0x5b5e139f657contract ERC721Metadata is Dummy, ERC165 {658 /// @notice A descriptive name for a collection of RFTs in this contract659 /// @dev EVM selector for this function is: 0x06fdde03,660 /// or in textual repr: name()661 function name() public view returns (string memory) {662 require(false, stub_error);663 dummy;664 return "";665 }666667 /// @notice An abbreviated name for RFTs in this contract668 /// @dev EVM selector for this function is: 0x95d89b41,669 /// or in textual repr: symbol()670 function symbol() public view returns (string memory) {671 require(false, stub_error);672 dummy;673 return "";674 }675676 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.677 ///678 /// @dev If the token has a `url` property and it is not empty, it is returned.679 /// 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`.680 /// If the collection property `baseURI` is empty or absent, return "" (empty string)681 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix682 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).683 ///684 /// @return token's const_metadata685 /// @dev EVM selector for this function is: 0xc87b56dd,686 /// or in textual repr: tokenURI(uint256)687 function tokenURI(uint256 tokenId) public view returns (string memory) {688 require(false, stub_error);689 tokenId;690 dummy;691 return "";692 }693}694695/// @dev inlined interface696contract ERC721Events {697 event Transfer(698 address indexed from,699 address indexed to,700 uint256 indexed tokenId701 );702 event Approval(703 address indexed owner,704 address indexed approved,705 uint256 indexed tokenId706 );707 event ApprovalForAll(708 address indexed owner,709 address indexed operator,710 bool approved711 );712}713714/// @title ERC-721 Non-Fungible Token Standard715/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md716/// @dev the ERC-165 identifier for this interface is 0x58800161717contract ERC721 is Dummy, ERC165, ERC721Events {718 /// @notice Count all RFTs assigned to an owner719 /// @dev RFTs assigned to the zero address are considered invalid, and this720 /// function throws for queries about the zero address.721 /// @param owner An address for whom to query the balance722 /// @return The number of RFTs owned by `owner`, possibly zero723 /// @dev EVM selector for this function is: 0x70a08231,724 /// or in textual repr: balanceOf(address)725 function balanceOf(address owner) public view returns (uint256) {726 require(false, stub_error);727 owner;728 dummy;729 return 0;730 }731732 /// @notice Find the owner of an RFT733 /// @dev RFTs assigned to zero address are considered invalid, and queries734 /// about them do throw.735 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for736 /// the tokens that are partially owned.737 /// @param tokenId The identifier for an RFT738 /// @return The address of the owner of the RFT739 /// @dev EVM selector for this function is: 0x6352211e,740 /// or in textual repr: ownerOf(uint256)741 function ownerOf(uint256 tokenId) public view returns (address) {742 require(false, stub_error);743 tokenId;744 dummy;745 return 0x0000000000000000000000000000000000000000;746 }747748 /// @dev Not implemented749 /// @dev EVM selector for this function is: 0x60a11672,750 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)751 function safeTransferFromWithData(752 address from,753 address to,754 uint256 tokenId,755 bytes memory data756 ) public {757 require(false, stub_error);758 from;759 to;760 tokenId;761 data;762 dummy = 0;763 }764765 /// @dev Not implemented766 /// @dev EVM selector for this function is: 0x42842e0e,767 /// or in textual repr: safeTransferFrom(address,address,uint256)768 function safeTransferFrom(769 address from,770 address to,771 uint256 tokenId772 ) public {773 require(false, stub_error);774 from;775 to;776 tokenId;777 dummy = 0;778 }779780 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE781 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE782 /// THEY MAY BE PERMANENTLY LOST783 /// @dev Throws unless `msg.sender` is the current owner or an authorized784 /// operator for this RFT. Throws if `from` is not the current owner. Throws785 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.786 /// Throws if RFT pieces have multiple owners.787 /// @param from The current owner of the NFT788 /// @param to The new owner789 /// @param tokenId The NFT to transfer790 /// @dev EVM selector for this function is: 0x23b872dd,791 /// or in textual repr: transferFrom(address,address,uint256)792 function transferFrom(793 address from,794 address to,795 uint256 tokenId796 ) public {797 require(false, stub_error);798 from;799 to;800 tokenId;801 dummy = 0;802 }803804 /// @dev Not implemented805 /// @dev EVM selector for this function is: 0x095ea7b3,806 /// or in textual repr: approve(address,uint256)807 function approve(address approved, uint256 tokenId) public {808 require(false, stub_error);809 approved;810 tokenId;811 dummy = 0;812 }813814 /// @dev Not implemented815 /// @dev EVM selector for this function is: 0xa22cb465,816 /// or in textual repr: setApprovalForAll(address,bool)817 function setApprovalForAll(address operator, bool approved) public {818 require(false, stub_error);819 operator;820 approved;821 dummy = 0;822 }823824 /// @dev Not implemented825 /// @dev EVM selector for this function is: 0x081812fc,826 /// or in textual repr: getApproved(uint256)827 function getApproved(uint256 tokenId) public view returns (address) {828 require(false, stub_error);829 tokenId;830 dummy;831 return 0x0000000000000000000000000000000000000000;832 }833834 /// @dev Not implemented835 /// @dev EVM selector for this function is: 0xe985e9c5,836 /// or in textual repr: isApprovedForAll(address,address)837 function isApprovedForAll(address owner, address operator)838 public839 view840 returns (address)841 {842 require(false, stub_error);843 owner;844 operator;845 dummy;846 return 0x0000000000000000000000000000000000000000;847 }848}849850contract UniqueRefungible is851 Dummy,852 ERC165,853 ERC721,854 ERC721Metadata,855 ERC721Enumerable,856 ERC721UniqueExtensions,857 ERC721Mintable,858 ERC721Burnable,859 Collection,860 TokenProperties861{}