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 0xde0695c222contract 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(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {32 // require(false, stub_error);33 // key;34 // isMutable;35 // collectionAdmin;36 // tokenOwner;37 // dummy = 0;38 // }3940 /// @notice Set permissions for token property.41 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.42 /// @param permissions Permissions for keys.43 /// @dev EVM selector for this function is: 0xbd92983a,44 /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])45 function setTokenPropertyPermissions(TokenPropertyPermission[] memory permissions) public {46 require(false, stub_error);47 permissions;48 dummy = 0;49 }5051 /// @notice Get permissions for token properties.52 /// @dev EVM selector for this function is: 0xf23d7790,53 /// or in textual repr: tokenPropertyPermissions()54 function tokenPropertyPermissions() public view returns (TokenPropertyPermission[] memory) {55 require(false, stub_error);56 dummy;57 return new TokenPropertyPermission[](0);58 }5960 // /// @notice Set token property value.61 // /// @dev Throws error if `msg.sender` has no permission to edit the property.62 // /// @param tokenId ID of the token.63 // /// @param key Property key.64 // /// @param value Property value.65 // /// @dev EVM selector for this function is: 0x1752d67b,66 // /// or in textual repr: setProperty(uint256,string,bytes)67 // function setProperty(uint256 tokenId, string memory key, bytes memory value) public {68 // require(false, stub_error);69 // tokenId;70 // key;71 // value;72 // dummy = 0;73 // }7475 /// @notice Set token properties value.76 /// @dev Throws error if `msg.sender` has no permission to edit the property.77 /// @param tokenId ID of the token.78 /// @param properties settable properties79 /// @dev EVM selector for this function is: 0x14ed3a6e,80 /// or in textual repr: setProperties(uint256,(string,bytes)[])81 function setProperties(uint256 tokenId, Property[] memory properties) public {82 require(false, stub_error);83 tokenId;84 properties;85 dummy = 0;86 }8788 // /// @notice Delete token property value.89 // /// @dev Throws error if `msg.sender` has no permission to edit the property.90 // /// @param tokenId ID of the token.91 // /// @param key Property key.92 // /// @dev EVM selector for this function is: 0x066111d1,93 // /// or in textual repr: deleteProperty(uint256,string)94 // function deleteProperty(uint256 tokenId, string memory key) public {95 // require(false, stub_error);96 // tokenId;97 // key;98 // dummy = 0;99 // }100101 /// @notice Delete token properties value.102 /// @dev Throws error if `msg.sender` has no permission to edit the property.103 /// @param tokenId ID of the token.104 /// @param keys Properties key.105 /// @dev EVM selector for this function is: 0xc472d371,106 /// or in textual repr: deleteProperties(uint256,string[])107 function deleteProperties(uint256 tokenId, string[] memory keys) public {108 require(false, stub_error);109 tokenId;110 keys;111 dummy = 0;112 }113114 /// @notice Get token property value.115 /// @dev Throws error if key not found116 /// @param tokenId ID of the token.117 /// @param key Property key.118 /// @return Property value bytes119 /// @dev EVM selector for this function is: 0x7228c327,120 /// or in textual repr: property(uint256,string)121 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {122 require(false, stub_error);123 tokenId;124 key;125 dummy;126 return hex"";127 }128}129130/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).131struct Property {132 string key;133 bytes value;134}135136/// Ethereum representation of Token Property Permissions.137struct TokenPropertyPermission {138 /// Token property key.139 string key;140 /// Token property permissions.141 PropertyPermission[] permissions;142}143144/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.145struct PropertyPermission {146 /// TokenPermission field.147 TokenPermissionField code;148 /// TokenPermission value.149 bool value;150}151152/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.153enum TokenPermissionField {154 /// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]155 Mutable,156 /// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]157 TokenOwner,158 /// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]159 CollectionAdmin160}161162/// @title A contract that allows you to work with collections.163/// @dev the ERC-165 identifier for this interface is 0x2a14cfd1164contract Collection is Dummy, ERC165 {165 // /// Set collection property.166 // ///167 // /// @param key Property key.168 // /// @param value Propery value.169 // /// @dev EVM selector for this function is: 0x2f073f66,170 // /// or in textual repr: setCollectionProperty(string,bytes)171 // function setCollectionProperty(string memory key, bytes memory value) public {172 // require(false, stub_error);173 // key;174 // value;175 // dummy = 0;176 // }177178 /// Set collection properties.179 ///180 /// @param properties Vector of properties key/value pair.181 /// @dev EVM selector for this function is: 0x50b26b2a,182 /// or in textual repr: setCollectionProperties((string,bytes)[])183 function setCollectionProperties(Property[] memory properties) public {184 require(false, stub_error);185 properties;186 dummy = 0;187 }188189 // /// Delete collection property.190 // ///191 // /// @param key Property key.192 // /// @dev EVM selector for this function is: 0x7b7debce,193 // /// or in textual repr: deleteCollectionProperty(string)194 // function deleteCollectionProperty(string memory key) public {195 // require(false, stub_error);196 // key;197 // dummy = 0;198 // }199200 /// Delete collection properties.201 ///202 /// @param keys Properties keys.203 /// @dev EVM selector for this function is: 0xee206ee3,204 /// or in textual repr: deleteCollectionProperties(string[])205 function deleteCollectionProperties(string[] memory keys) public {206 require(false, stub_error);207 keys;208 dummy = 0;209 }210211 /// Get collection property.212 ///213 /// @dev Throws error if key not found.214 ///215 /// @param key Property key.216 /// @return bytes The property corresponding to the key.217 /// @dev EVM selector for this function is: 0xcf24fd6d,218 /// or in textual repr: collectionProperty(string)219 function collectionProperty(string memory key) public view returns (bytes memory) {220 require(false, stub_error);221 key;222 dummy;223 return hex"";224 }225226 /// Get collection properties.227 ///228 /// @param keys Properties keys. Empty keys for all propertyes.229 /// @return Vector of properties key/value pairs.230 /// @dev EVM selector for this function is: 0x285fb8e6,231 /// or in textual repr: collectionProperties(string[])232 function collectionProperties(string[] memory keys) public view returns (Property[] memory) {233 require(false, stub_error);234 keys;235 dummy;236 return new Property[](0);237 }238239 // /// Set the sponsor of the collection.240 // ///241 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.242 // ///243 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.244 // /// @dev EVM selector for this function is: 0x7623402e,245 // /// or in textual repr: setCollectionSponsor(address)246 // function setCollectionSponsor(address sponsor) public {247 // require(false, stub_error);248 // sponsor;249 // dummy = 0;250 // }251252 /// Set the sponsor of the collection.253 ///254 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.255 ///256 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.257 /// @dev EVM selector for this function is: 0x84a1d5a8,258 /// or in textual repr: setCollectionSponsorCross((address,uint256))259 function setCollectionSponsorCross(CrossAddress memory sponsor) public {260 require(false, stub_error);261 sponsor;262 dummy = 0;263 }264265 /// Whether there is a pending sponsor.266 /// @dev EVM selector for this function is: 0x058ac185,267 /// or in textual repr: hasCollectionPendingSponsor()268 function hasCollectionPendingSponsor() public view returns (bool) {269 require(false, stub_error);270 dummy;271 return false;272 }273274 /// Collection sponsorship confirmation.275 ///276 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.277 /// @dev EVM selector for this function is: 0x3c50e97a,278 /// or in textual repr: confirmCollectionSponsorship()279 function confirmCollectionSponsorship() public {280 require(false, stub_error);281 dummy = 0;282 }283284 /// Remove collection sponsor.285 /// @dev EVM selector for this function is: 0x6e0326a3,286 /// or in textual repr: removeCollectionSponsor()287 function removeCollectionSponsor() public {288 require(false, stub_error);289 dummy = 0;290 }291292 /// Get current sponsor.293 ///294 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.295 /// @dev EVM selector for this function is: 0x6ec0a9f1,296 /// or in textual repr: collectionSponsor()297 function collectionSponsor() public view returns (CrossAddress memory) {298 require(false, stub_error);299 dummy;300 return CrossAddress(0x0000000000000000000000000000000000000000, 0);301 }302303 /// Get current collection limits.304 ///305 /// @return Array of collection limits306 /// @dev EVM selector for this function is: 0xf63bc572,307 /// or in textual repr: collectionLimits()308 function collectionLimits() public view returns (CollectionLimit[] memory) {309 require(false, stub_error);310 dummy;311 return new CollectionLimit[](0);312 }313314 /// Set limits for the collection.315 /// @dev Throws error if limit not found.316 /// @param limit Some limit.317 /// @dev EVM selector for this function is: 0x2316ee74,318 /// or in textual repr: setCollectionLimit((uint8,(bool,uint256)))319 function setCollectionLimit(CollectionLimit memory limit) public {320 require(false, stub_error);321 limit;322 dummy = 0;323 }324325 /// Get contract address.326 /// @dev EVM selector for this function is: 0xf6b4dfb4,327 /// or in textual repr: contractAddress()328 function contractAddress() public view returns (address) {329 require(false, stub_error);330 dummy;331 return 0x0000000000000000000000000000000000000000;332 }333334 /// Add collection admin.335 /// @param newAdmin Cross account administrator address.336 /// @dev EVM selector for this function is: 0x859aa7d6,337 /// or in textual repr: addCollectionAdminCross((address,uint256))338 function addCollectionAdminCross(CrossAddress memory newAdmin) public {339 require(false, stub_error);340 newAdmin;341 dummy = 0;342 }343344 /// Remove collection admin.345 /// @param admin Cross account administrator address.346 /// @dev EVM selector for this function is: 0x6c0cd173,347 /// or in textual repr: removeCollectionAdminCross((address,uint256))348 function removeCollectionAdminCross(CrossAddress memory admin) public {349 require(false, stub_error);350 admin;351 dummy = 0;352 }353354 // /// Add collection admin.355 // /// @param newAdmin Address of the added administrator.356 // /// @dev EVM selector for this function is: 0x92e462c7,357 // /// or in textual repr: addCollectionAdmin(address)358 // function addCollectionAdmin(address newAdmin) public {359 // require(false, stub_error);360 // newAdmin;361 // dummy = 0;362 // }363364 // /// Remove collection admin.365 // ///366 // /// @param admin Address of the removed administrator.367 // /// @dev EVM selector for this function is: 0xfafd7b42,368 // /// or in textual repr: removeCollectionAdmin(address)369 // function removeCollectionAdmin(address admin) public {370 // require(false, stub_error);371 // admin;372 // dummy = 0;373 // }374375 /// Toggle accessibility of collection nesting.376 ///377 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'378 /// @dev EVM selector for this function is: 0x112d4586,379 /// or in textual repr: setCollectionNesting(bool)380 function setCollectionNesting(bool enable) public {381 require(false, stub_error);382 enable;383 dummy = 0;384 }385386 /// Toggle accessibility of collection nesting.387 ///388 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'389 /// @param collections Addresses of collections that will be available for nesting.390 /// @dev EVM selector for this function is: 0x64872396,391 /// or in textual repr: setCollectionNesting(bool,address[])392 function setCollectionNesting(bool enable, address[] memory collections) public {393 require(false, stub_error);394 enable;395 collections;396 dummy = 0;397 }398399 /// Returns nesting for a collection400 /// @dev EVM selector for this function is: 0x22d25bfe,401 /// or in textual repr: collectionNestingRestrictedCollectionIds()402 function collectionNestingRestrictedCollectionIds() public view returns (CollectionNesting memory) {403 require(false, stub_error);404 dummy;405 return CollectionNesting(false, new uint256[](0));406 }407408 /// Returns permissions for a collection409 /// @dev EVM selector for this function is: 0x5b2eaf4b,410 /// or in textual repr: collectionNestingPermissions()411 function collectionNestingPermissions() public view returns (CollectionNestingPermission[] memory) {412 require(false, stub_error);413 dummy;414 return new CollectionNestingPermission[](0);415 }416417 /// Set the collection access method.418 /// @param mode Access mode419 /// 0 for Normal420 /// 1 for AllowList421 /// @dev EVM selector for this function is: 0x41835d4c,422 /// or in textual repr: setCollectionAccess(uint8)423 function setCollectionAccess(uint8 mode) public {424 require(false, stub_error);425 mode;426 dummy = 0;427 }428429 /// Checks that user allowed to operate with collection.430 ///431 /// @param user User address to check.432 /// @dev EVM selector for this function is: 0x91b6df49,433 /// or in textual repr: allowlistedCross((address,uint256))434 function allowlistedCross(CrossAddress memory user) public view returns (bool) {435 require(false, stub_error);436 user;437 dummy;438 return false;439 }440441 // /// Add the user to the allowed list.442 // ///443 // /// @param user Address of a trusted user.444 // /// @dev EVM selector for this function is: 0x67844fe6,445 // /// or in textual repr: addToCollectionAllowList(address)446 // function addToCollectionAllowList(address user) public {447 // require(false, stub_error);448 // user;449 // dummy = 0;450 // }451452 /// Add user to allowed list.453 ///454 /// @param user User cross account address.455 /// @dev EVM selector for this function is: 0xa0184a3a,456 /// or in textual repr: addToCollectionAllowListCross((address,uint256))457 function addToCollectionAllowListCross(CrossAddress memory user) public {458 require(false, stub_error);459 user;460 dummy = 0;461 }462463 // /// Remove the user from the allowed list.464 // ///465 // /// @param user Address of a removed user.466 // /// @dev EVM selector for this function is: 0x85c51acb,467 // /// or in textual repr: removeFromCollectionAllowList(address)468 // function removeFromCollectionAllowList(address user) public {469 // require(false, stub_error);470 // user;471 // dummy = 0;472 // }473474 /// Remove user from allowed list.475 ///476 /// @param user User cross account address.477 /// @dev EVM selector for this function is: 0x09ba452a,478 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))479 function removeFromCollectionAllowListCross(CrossAddress memory user) public {480 require(false, stub_error);481 user;482 dummy = 0;483 }484485 /// Switch permission for minting.486 ///487 /// @param mode Enable if "true".488 /// @dev EVM selector for this function is: 0x00018e84,489 /// or in textual repr: setCollectionMintMode(bool)490 function setCollectionMintMode(bool mode) public {491 require(false, stub_error);492 mode;493 dummy = 0;494 }495496 // /// Check that account is the owner or admin of the collection497 // ///498 // /// @param user account to verify499 // /// @return "true" if account is the owner or admin500 // /// @dev EVM selector for this function is: 0x9811b0c7,501 // /// or in textual repr: isOwnerOrAdmin(address)502 // function isOwnerOrAdmin(address user) public view returns (bool) {503 // require(false, stub_error);504 // user;505 // dummy;506 // return false;507 // }508509 /// Check that account is the owner or admin of the collection510 ///511 /// @param user User cross account to verify512 /// @return "true" if account is the owner or admin513 /// @dev EVM selector for this function is: 0x3e75a905,514 /// or in textual repr: isOwnerOrAdminCross((address,uint256))515 function isOwnerOrAdminCross(CrossAddress memory user) public view returns (bool) {516 require(false, stub_error);517 user;518 dummy;519 return false;520 }521522 /// Returns collection type523 ///524 /// @return `Fungible` or `NFT` or `ReFungible`525 /// @dev EVM selector for this function is: 0xd34b55b8,526 /// or in textual repr: uniqueCollectionType()527 function uniqueCollectionType() public view returns (string memory) {528 require(false, stub_error);529 dummy;530 return "";531 }532533 /// Get collection owner.534 ///535 /// @return Tuble with sponsor address and his substrate mirror.536 /// If address is canonical then substrate mirror is zero and vice versa.537 /// @dev EVM selector for this function is: 0xdf727d3b,538 /// or in textual repr: collectionOwner()539 function collectionOwner() public view returns (CrossAddress memory) {540 require(false, stub_error);541 dummy;542 return CrossAddress(0x0000000000000000000000000000000000000000, 0);543 }544545 // /// Changes collection owner to another account546 // ///547 // /// @dev Owner can be changed only by current owner548 // /// @param newOwner new owner account549 // /// @dev EVM selector for this function is: 0x4f53e226,550 // /// or in textual repr: changeCollectionOwner(address)551 // function changeCollectionOwner(address newOwner) public {552 // require(false, stub_error);553 // newOwner;554 // dummy = 0;555 // }556557 /// Get collection administrators558 ///559 /// @return Vector of tuples with admins address and his substrate mirror.560 /// If address is canonical then substrate mirror is zero and vice versa.561 /// @dev EVM selector for this function is: 0x5813216b,562 /// or in textual repr: collectionAdmins()563 function collectionAdmins() public view returns (CrossAddress[] memory) {564 require(false, stub_error);565 dummy;566 return new CrossAddress[](0);567 }568569 /// Changes collection owner to another account570 ///571 /// @dev Owner can be changed only by current owner572 /// @param newOwner new owner cross account573 /// @dev EVM selector for this function is: 0x6496c497,574 /// or in textual repr: changeCollectionOwnerCross((address,uint256))575 function changeCollectionOwnerCross(CrossAddress memory newOwner) public {576 require(false, stub_error);577 newOwner;578 dummy = 0;579 }580}581582/// Cross account struct583struct CrossAddress {584 address eth;585 uint256 sub;586}587588/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.589struct CollectionNestingPermission {590 CollectionPermissionField field;591 bool value;592}593594/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.595enum CollectionPermissionField {596 /// Owner of token can nest tokens under it.597 TokenOwner,598 /// Admin of token collection can nest tokens under token.599 CollectionAdmin600}601602/// Nested collections.603struct CollectionNesting {604 bool token_owner;605 uint256[] ids;606}607608/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.609struct CollectionLimit {610 CollectionLimitField field;611 OptionUint256 value;612}613614/// Optional value615struct OptionUint256 {616 /// Shows the status of accessibility of value617 bool status;618 /// Actual value if `status` is true619 uint256 value;620}621622/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.623enum CollectionLimitField {624 /// How many tokens can a user have on one account.625 AccountTokenOwnership,626 /// How many bytes of data are available for sponsorship.627 SponsoredDataSize,628 /// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]629 SponsoredDataRateLimit,630 /// How many tokens can be mined into this collection.631 TokenLimit,632 /// Timeouts for transfer sponsoring.633 SponsorTransferTimeout,634 /// Timeout for sponsoring an approval in passed blocks.635 SponsorApproveTimeout,636 /// Whether the collection owner of the collection can send tokens (which belong to other users).637 OwnerCanTransfer,638 /// Can the collection owner burn other people's tokens.639 OwnerCanDestroy,640 /// Is it possible to send tokens from this collection between users.641 TransferEnabled642}643644/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension645/// @dev See https://eips.ethereum.org/EIPS/eip-721646/// @dev the ERC-165 identifier for this interface is 0x5b5e139f647contract ERC721Metadata is Dummy, ERC165 {648 // /// @notice A descriptive name for a collection of NFTs in this contract649 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`650 // /// @dev EVM selector for this function is: 0x06fdde03,651 // /// or in textual repr: name()652 // function name() public view returns (string memory) {653 // require(false, stub_error);654 // dummy;655 // return "";656 // }657658 // /// @notice An abbreviated name for NFTs in this contract659 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`660 // /// @dev EVM selector for this function is: 0x95d89b41,661 // /// or in textual repr: symbol()662 // function symbol() public view returns (string memory) {663 // require(false, stub_error);664 // dummy;665 // return "";666 // }667668 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.669 ///670 /// @dev If the token has a `url` property and it is not empty, it is returned.671 /// 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`.672 /// If the collection property `baseURI` is empty or absent, return "" (empty string)673 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix674 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).675 ///676 /// @return token's const_metadata677 /// @dev EVM selector for this function is: 0xc87b56dd,678 /// or in textual repr: tokenURI(uint256)679 function tokenURI(uint256 tokenId) public view returns (string memory) {680 require(false, stub_error);681 tokenId;682 dummy;683 return "";684 }685}686687/// @title ERC721 Token that can be irreversibly burned (destroyed).688/// @dev the ERC-165 identifier for this interface is 0x42966c68689contract ERC721Burnable is Dummy, ERC165 {690 /// @notice Burns a specific ERC721 token.691 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized692 /// operator of the current owner.693 /// @param tokenId The RFT to approve694 /// @dev EVM selector for this function is: 0x42966c68,695 /// or in textual repr: burn(uint256)696 function burn(uint256 tokenId) public {697 require(false, stub_error);698 tokenId;699 dummy = 0;700 }701}702703/// @title ERC721 minting logic.704/// @dev the ERC-165 identifier for this interface is 0x3fd94ea6705contract ERC721UniqueMintable is Dummy, ERC165 {706 /// @notice Function to mint a token.707 /// @param to The new owner708 /// @return uint256 The id of the newly minted token709 /// @dev EVM selector for this function is: 0x6a627842,710 /// or in textual repr: mint(address)711 function mint(address to) public returns (uint256) {712 require(false, stub_error);713 to;714 dummy = 0;715 return 0;716 }717718 // /// @notice Function to mint a token.719 // /// @dev `tokenId` should be obtained with `nextTokenId` method,720 // /// unlike standard, you can't specify it manually721 // /// @param to The new owner722 // /// @param tokenId ID of the minted RFT723 // /// @dev EVM selector for this function is: 0x40c10f19,724 // /// or in textual repr: mint(address,uint256)725 // function mint(address to, uint256 tokenId) public returns (bool) {726 // require(false, stub_error);727 // to;728 // tokenId;729 // dummy = 0;730 // return false;731 // }732733 /// @notice Function to mint token with the given tokenUri.734 /// @param to The new owner735 /// @param tokenUri Token URI that would be stored in the NFT properties736 /// @return uint256 The id of the newly minted token737 /// @dev EVM selector for this function is: 0x45c17782,738 /// or in textual repr: mintWithTokenURI(address,string)739 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {740 require(false, stub_error);741 to;742 tokenUri;743 dummy = 0;744 return 0;745 }746 // /// @notice Function to mint token with the given tokenUri.747 // /// @dev `tokenId` should be obtained with `nextTokenId` method,748 // /// unlike standard, you can't specify it manually749 // /// @param to The new owner750 // /// @param tokenId ID of the minted RFT751 // /// @param tokenUri Token URI that would be stored in the RFT properties752 // /// @dev EVM selector for this function is: 0x50bb4e7f,753 // /// or in textual repr: mintWithTokenURI(address,uint256,string)754 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {755 // require(false, stub_error);756 // to;757 // tokenId;758 // tokenUri;759 // dummy = 0;760 // return false;761 // }762763}764765/// @title Unique extensions for ERC721.766/// @dev the ERC-165 identifier for this interface is 0xb365c124767contract ERC721UniqueExtensions is Dummy, ERC165 {768 /// @notice A descriptive name for a collection of NFTs in this contract769 /// @dev EVM selector for this function is: 0x06fdde03,770 /// or in textual repr: name()771 function name() public view returns (string memory) {772 require(false, stub_error);773 dummy;774 return "";775 }776777 /// @notice An abbreviated name for NFTs in this contract778 /// @dev EVM selector for this function is: 0x95d89b41,779 /// or in textual repr: symbol()780 function symbol() public view returns (string memory) {781 require(false, stub_error);782 dummy;783 return "";784 }785786 /// @notice A description for the collection.787 /// @dev EVM selector for this function is: 0x7284e416,788 /// or in textual repr: description()789 function description() public view returns (string memory) {790 require(false, stub_error);791 dummy;792 return "";793 }794795 /// Returns the owner (in cross format) of the token.796 ///797 /// @param tokenId Id for the token.798 /// @dev EVM selector for this function is: 0x2b29dace,799 /// or in textual repr: crossOwnerOf(uint256)800 function crossOwnerOf(uint256 tokenId) public view returns (CrossAddress memory) {801 require(false, stub_error);802 tokenId;803 dummy;804 return CrossAddress(0x0000000000000000000000000000000000000000, 0);805 }806807 /// Returns the token properties.808 ///809 /// @param tokenId Id for the token.810 /// @param keys Properties keys. Empty keys for all propertyes.811 /// @return Vector of properties key/value pairs.812 /// @dev EVM selector for this function is: 0xe07ede7e,813 /// or in textual repr: properties(uint256,string[])814 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {815 require(false, stub_error);816 tokenId;817 keys;818 dummy;819 return new Property[](0);820 }821822 /// @notice Transfer ownership of an RFT823 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`824 /// is the zero address. Throws if `tokenId` is not a valid RFT.825 /// Throws if RFT pieces have multiple owners.826 /// @param to The new owner827 /// @param tokenId The RFT to transfer828 /// @dev EVM selector for this function is: 0xa9059cbb,829 /// or in textual repr: transfer(address,uint256)830 function transfer(address to, uint256 tokenId) public {831 require(false, stub_error);832 to;833 tokenId;834 dummy = 0;835 }836837 /// @notice Transfer ownership of an RFT838 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`839 /// is the zero address. Throws if `tokenId` is not a valid RFT.840 /// Throws if RFT pieces have multiple owners.841 /// @param to The new owner842 /// @param tokenId The RFT to transfer843 /// @dev EVM selector for this function is: 0x2ada85ff,844 /// or in textual repr: transferCross((address,uint256),uint256)845 function transferCross(CrossAddress memory to, uint256 tokenId) public {846 require(false, stub_error);847 to;848 tokenId;849 dummy = 0;850 }851852 /// @notice Transfer ownership of an RFT853 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`854 /// is the zero address. Throws if `tokenId` is not a valid RFT.855 /// Throws if RFT pieces have multiple owners.856 /// @param to The new owner857 /// @param tokenId The RFT to transfer858 /// @dev EVM selector for this function is: 0xd5cf430b,859 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)860 function transferFromCross(861 CrossAddress memory from,862 CrossAddress memory to,863 uint256 tokenId864 ) public {865 require(false, stub_error);866 from;867 to;868 tokenId;869 dummy = 0;870 }871872 // /// @notice Burns a specific ERC721 token.873 // /// @dev Throws unless `msg.sender` is the current owner or an authorized874 // /// operator for this RFT. Throws if `from` is not the current owner. Throws875 // /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.876 // /// Throws if RFT pieces have multiple owners.877 // /// @param from The current owner of the RFT878 // /// @param tokenId The RFT to transfer879 // /// @dev EVM selector for this function is: 0x79cc6790,880 // /// or in textual repr: burnFrom(address,uint256)881 // function burnFrom(address from, uint256 tokenId) public {882 // require(false, stub_error);883 // from;884 // tokenId;885 // dummy = 0;886 // }887888 /// @notice Burns a specific ERC721 token.889 /// @dev Throws unless `msg.sender` is the current owner or an authorized890 /// operator for this RFT. Throws if `from` is not the current owner. Throws891 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.892 /// Throws if RFT pieces have multiple owners.893 /// @param from The current owner of the RFT894 /// @param tokenId The RFT to transfer895 /// @dev EVM selector for this function is: 0xbb2f5a58,896 /// or in textual repr: burnFromCross((address,uint256),uint256)897 function burnFromCross(CrossAddress memory from, uint256 tokenId) public {898 require(false, stub_error);899 from;900 tokenId;901 dummy = 0;902 }903904 /// @notice Returns next free RFT ID.905 /// @dev EVM selector for this function is: 0x75794a3c,906 /// or in textual repr: nextTokenId()907 function nextTokenId() public view returns (uint256) {908 require(false, stub_error);909 dummy;910 return 0;911 }912913 // /// @notice Function to mint multiple tokens.914 // /// @dev `tokenIds` should be an array of consecutive numbers and first number915 // /// should be obtained with `nextTokenId` method916 // /// @param to The new owner917 // /// @param tokenIds IDs of the minted RFTs918 // /// @dev EVM selector for this function is: 0x44a9945e,919 // /// or in textual repr: mintBulk(address,uint256[])920 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {921 // require(false, stub_error);922 // to;923 // tokenIds;924 // dummy = 0;925 // return false;926 // }927928 // /// @notice Function to mint multiple tokens with the given tokenUris.929 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive930 // /// numbers and first number should be obtained with `nextTokenId` method931 // /// @param to The new owner932 // /// @param tokens array of pairs of token ID and token URI for minted tokens933 // /// @dev EVM selector for this function is: 0x36543006,934 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])935 // function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {936 // require(false, stub_error);937 // to;938 // tokens;939 // dummy = 0;940 // return false;941 // }942943 /// @notice Function to mint a token.944 /// @param to The new owner crossAccountId945 /// @param properties Properties of minted token946 /// @return uint256 The id of the newly minted token947 /// @dev EVM selector for this function is: 0xb904db03,948 /// or in textual repr: mintCross((address,uint256),(string,bytes)[])949 function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {950 require(false, stub_error);951 to;952 properties;953 dummy = 0;954 return 0;955 }956957 /// Returns EVM address for refungible token958 ///959 /// @param token ID of the token960 /// @dev EVM selector for this function is: 0xab76fac6,961 /// or in textual repr: tokenContractAddress(uint256)962 function tokenContractAddress(uint256 token) public view returns (address) {963 require(false, stub_error);964 token;965 dummy;966 return 0x0000000000000000000000000000000000000000;967 }968969 /// @notice Returns collection helper contract address970 /// @dev EVM selector for this function is: 0x1896cce6,971 /// or in textual repr: collectionHelperAddress()972 function collectionHelperAddress() public view returns (address) {973 require(false, stub_error);974 dummy;975 return 0x0000000000000000000000000000000000000000;976 }977}978979/// @dev anonymous struct980struct Tuple14 {981 uint256 field_0;982 string field_1;983}984985/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension986/// @dev See https://eips.ethereum.org/EIPS/eip-721987/// @dev the ERC-165 identifier for this interface is 0x780e9d63988contract ERC721Enumerable is Dummy, ERC165 {989 /// @notice Enumerate valid RFTs990 /// @param index A counter less than `totalSupply()`991 /// @return The token identifier for the `index`th NFT,992 /// (sort order not specified)993 /// @dev EVM selector for this function is: 0x4f6ccce7,994 /// or in textual repr: tokenByIndex(uint256)995 function tokenByIndex(uint256 index) public view returns (uint256) {996 require(false, stub_error);997 index;998 dummy;999 return 0;1000 }10011002 /// Not implemented1003 /// @dev EVM selector for this function is: 0x2f745c59,1004 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)1005 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1006 require(false, stub_error);1007 owner;1008 index;1009 dummy;1010 return 0;1011 }10121013 /// @notice Count RFTs tracked by this contract1014 /// @return A count of valid RFTs tracked by this contract, where each one of1015 /// them has an assigned and queryable owner not equal to the zero address1016 /// @dev EVM selector for this function is: 0x18160ddd,1017 /// or in textual repr: totalSupply()1018 function totalSupply() public view returns (uint256) {1019 require(false, stub_error);1020 dummy;1021 return 0;1022 }1023}10241025/// @dev inlined interface1026contract ERC721Events {1027 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1028 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1029 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1030}10311032/// @title ERC-721 Non-Fungible Token Standard1033/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1034/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1035contract ERC721 is Dummy, ERC165, ERC721Events {1036 /// @notice Count all RFTs assigned to an owner1037 /// @dev RFTs assigned to the zero address are considered invalid, and this1038 /// function throws for queries about the zero address.1039 /// @param owner An address for whom to query the balance1040 /// @return The number of RFTs owned by `owner`, possibly zero1041 /// @dev EVM selector for this function is: 0x70a08231,1042 /// or in textual repr: balanceOf(address)1043 function balanceOf(address owner) public view returns (uint256) {1044 require(false, stub_error);1045 owner;1046 dummy;1047 return 0;1048 }10491050 /// @notice Find the owner of an RFT1051 /// @dev RFTs assigned to zero address are considered invalid, and queries1052 /// about them do throw.1053 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1054 /// the tokens that are partially owned.1055 /// @param tokenId The identifier for an RFT1056 /// @return The address of the owner of the RFT1057 /// @dev EVM selector for this function is: 0x6352211e,1058 /// or in textual repr: ownerOf(uint256)1059 function ownerOf(uint256 tokenId) public view returns (address) {1060 require(false, stub_error);1061 tokenId;1062 dummy;1063 return 0x0000000000000000000000000000000000000000;1064 }10651066 /// @dev Not implemented1067 /// @dev EVM selector for this function is: 0xb88d4fde,1068 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)1069 function safeTransferFrom(1070 address from,1071 address to,1072 uint256 tokenId,1073 bytes memory data1074 ) public {1075 require(false, stub_error);1076 from;1077 to;1078 tokenId;1079 data;1080 dummy = 0;1081 }10821083 /// @dev Not implemented1084 /// @dev EVM selector for this function is: 0x42842e0e,1085 /// or in textual repr: safeTransferFrom(address,address,uint256)1086 function safeTransferFrom(1087 address from,1088 address to,1089 uint256 tokenId1090 ) public {1091 require(false, stub_error);1092 from;1093 to;1094 tokenId;1095 dummy = 0;1096 }10971098 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1099 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1100 /// THEY MAY BE PERMANENTLY LOST1101 /// @dev Throws unless `msg.sender` is the current owner or an authorized1102 /// operator for this RFT. Throws if `from` is not the current owner. Throws1103 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1104 /// Throws if RFT pieces have multiple owners.1105 /// @param from The current owner of the NFT1106 /// @param to The new owner1107 /// @param tokenId The NFT to transfer1108 /// @dev EVM selector for this function is: 0x23b872dd,1109 /// or in textual repr: transferFrom(address,address,uint256)1110 function transferFrom(1111 address from,1112 address to,1113 uint256 tokenId1114 ) public {1115 require(false, stub_error);1116 from;1117 to;1118 tokenId;1119 dummy = 0;1120 }11211122 /// @dev Not implemented1123 /// @dev EVM selector for this function is: 0x095ea7b3,1124 /// or in textual repr: approve(address,uint256)1125 function approve(address approved, uint256 tokenId) public {1126 require(false, stub_error);1127 approved;1128 tokenId;1129 dummy = 0;1130 }11311132 /// @notice Sets or unsets the approval of a given operator.1133 /// The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1134 /// @param operator Operator1135 /// @param approved Should operator status be granted or revoked?1136 /// @dev EVM selector for this function is: 0xa22cb465,1137 /// or in textual repr: setApprovalForAll(address,bool)1138 function setApprovalForAll(address operator, bool approved) public {1139 require(false, stub_error);1140 operator;1141 approved;1142 dummy = 0;1143 }11441145 /// @dev Not implemented1146 /// @dev EVM selector for this function is: 0x081812fc,1147 /// or in textual repr: getApproved(uint256)1148 function getApproved(uint256 tokenId) public view returns (address) {1149 require(false, stub_error);1150 tokenId;1151 dummy;1152 return 0x0000000000000000000000000000000000000000;1153 }11541155 /// @notice Tells whether the given `owner` approves the `operator`.1156 /// @dev EVM selector for this function is: 0xe985e9c5,1157 /// or in textual repr: isApprovedForAll(address,address)1158 function isApprovedForAll(address owner, address operator) public view returns (bool) {1159 require(false, stub_error);1160 owner;1161 operator;1162 dummy;1163 return false;1164 }1165}11661167contract UniqueRefungible is1168 Dummy,1169 ERC165,1170 ERC721,1171 ERC721Enumerable,1172 ERC721UniqueExtensions,1173 ERC721UniqueMintable,1174 ERC721Burnable,1175 ERC721Metadata,1176 Collection,1177 TokenProperties1178{}