1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7interface Dummy {89}1011interface ERC165 is Dummy {12 function supportsInterface(bytes4 interfaceID) external view returns (bool);13}1415/// @title A contract that allows to set and delete token properties and change token property permissions.16/// @dev the ERC-165 identifier for this interface is 0xde0695c217interface TokenProperties is Dummy, ERC165 {18 // /// @notice Set permissions for token property.19 // /// @dev Throws error if `msg.sender` is not admin or owner of the collection.20 // /// @param key Property key.21 // /// @param isMutable Permission to mutate property.22 // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.23 // /// @param tokenOwner Permission to mutate property by token owner if property is mutable.24 // /// @dev EVM selector for this function is: 0x222d97fa,25 // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)26 // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) external;2728 /// @notice Set permissions for token property.29 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.30 /// @param permissions Permissions for keys.31 /// @dev EVM selector for this function is: 0xbd92983a,32 /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])33<<<<<<< HEAD34 function setTokenPropertyPermissions(Tuple51[] memory permissions) external;35=======36 function setTokenPropertyPermissions(Tuple48[] memory permissions) external;37>>>>>>> 9e929f90... chore: generate stubs & types3839 /// @notice Get permissions for token properties.40 /// @dev EVM selector for this function is: 0xf23d7790,41 /// or in textual repr: tokenPropertyPermissions()42<<<<<<< HEAD43 function tokenPropertyPermissions() external view returns (Tuple51[] memory);44=======45 function tokenPropertyPermissions() external view returns (Tuple48[] memory);46>>>>>>> 9e929f90... chore: generate stubs & types4748 // /// @notice Set token property value.49 // /// @dev Throws error if `msg.sender` has no permission to edit the property.50 // /// @param tokenId ID of the token.51 // /// @param key Property key.52 // /// @param value Property value.53 // /// @dev EVM selector for this function is: 0x1752d67b,54 // /// or in textual repr: setProperty(uint256,string,bytes)55 // function setProperty(uint256 tokenId, string memory key, bytes memory value) external;5657 /// @notice Set token properties value.58 /// @dev Throws error if `msg.sender` has no permission to edit the property.59 /// @param tokenId ID of the token.60 /// @param properties settable properties61 /// @dev EVM selector for this function is: 0x14ed3a6e,62 /// or in textual repr: setProperties(uint256,(string,bytes)[])63 function setProperties(uint256 tokenId, Property[] memory properties) external;6465 // /// @notice Delete token property value.66 // /// @dev Throws error if `msg.sender` has no permission to edit the property.67 // /// @param tokenId ID of the token.68 // /// @param key Property key.69 // /// @dev EVM selector for this function is: 0x066111d1,70 // /// or in textual repr: deleteProperty(uint256,string)71 // function deleteProperty(uint256 tokenId, string memory key) external;7273 /// @notice Delete token properties value.74 /// @dev Throws error if `msg.sender` has no permission to edit the property.75 /// @param tokenId ID of the token.76 /// @param keys Properties key.77 /// @dev EVM selector for this function is: 0xc472d371,78 /// or in textual repr: deleteProperties(uint256,string[])79 function deleteProperties(uint256 tokenId, string[] memory keys) external;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) external view returns (bytes memory);89}9091/// @dev Property struct92struct Property {93 string key;94 bytes value;95}9697/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.98enum EthTokenPermissions {99 /// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]100 Mutable,101 /// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]102 TokenOwner,103 /// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]104 CollectionAdmin105}106107/// @dev anonymous struct108<<<<<<< HEAD109struct Tuple51 {110 string field_0;111 Tuple49[] field_1;112}113114/// @dev anonymous struct115struct Tuple49 {116=======117struct Tuple48 {118 string field_0;119 Tuple46[] field_1;120}121122/// @dev anonymous struct123struct Tuple46 {124>>>>>>> 9e929f90... chore: generate stubs & types125 EthTokenPermissions field_0;126 bool field_1;127}128129/// @title A contract that allows you to work with collections.130/// @dev the ERC-165 identifier for this interface is 0x81172a75131interface Collection is Dummy, ERC165 {132 // /// Set collection property.133 // ///134 // /// @param key Property key.135 // /// @param value Propery value.136 // /// @dev EVM selector for this function is: 0x2f073f66,137 // /// or in textual repr: setCollectionProperty(string,bytes)138 // function setCollectionProperty(string memory key, bytes memory value) external;139140 /// Set collection properties.141 ///142 /// @param properties Vector of properties key/value pair.143 /// @dev EVM selector for this function is: 0x50b26b2a,144 /// or in textual repr: setCollectionProperties((string,bytes)[])145 function setCollectionProperties(Property[] memory properties) external;146147 // /// Delete collection property.148 // ///149 // /// @param key Property key.150 // /// @dev EVM selector for this function is: 0x7b7debce,151 // /// or in textual repr: deleteCollectionProperty(string)152 // function deleteCollectionProperty(string memory key) external;153154 /// Delete collection properties.155 ///156 /// @param keys Properties keys.157 /// @dev EVM selector for this function is: 0xee206ee3,158 /// or in textual repr: deleteCollectionProperties(string[])159 function deleteCollectionProperties(string[] memory keys) external;160161 /// Get collection property.162 ///163 /// @dev Throws error if key not found.164 ///165 /// @param key Property key.166 /// @return bytes The property corresponding to the key.167 /// @dev EVM selector for this function is: 0xcf24fd6d,168 /// or in textual repr: collectionProperty(string)169 function collectionProperty(string memory key) external view returns (bytes memory);170171 /// Get collection properties.172 ///173 /// @param keys Properties keys. Empty keys for all propertyes.174 /// @return Vector of properties key/value pairs.175 /// @dev EVM selector for this function is: 0x285fb8e6,176 /// or in textual repr: collectionProperties(string[])177 function collectionProperties(string[] memory keys) external view returns (Property[] memory);178179 // /// Set the sponsor of the collection.180 // ///181 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.182 // ///183 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.184 // /// @dev EVM selector for this function is: 0x7623402e,185 // /// or in textual repr: setCollectionSponsor(address)186 // function setCollectionSponsor(address sponsor) external;187188 /// Set the sponsor of the collection.189 ///190 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.191 ///192 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.193 /// @dev EVM selector for this function is: 0x84a1d5a8,194 /// or in textual repr: setCollectionSponsorCross((address,uint256))195 function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;196197 /// Whether there is a pending sponsor.198 /// @dev EVM selector for this function is: 0x058ac185,199 /// or in textual repr: hasCollectionPendingSponsor()200 function hasCollectionPendingSponsor() external view returns (bool);201202 /// Collection sponsorship confirmation.203 ///204 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.205 /// @dev EVM selector for this function is: 0x3c50e97a,206 /// or in textual repr: confirmCollectionSponsorship()207 function confirmCollectionSponsorship() external;208209 /// Remove collection sponsor.210 /// @dev EVM selector for this function is: 0x6e0326a3,211 /// or in textual repr: removeCollectionSponsor()212 function removeCollectionSponsor() external;213214 /// Get current sponsor.215 ///216 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.217 /// @dev EVM selector for this function is: 0x6ec0a9f1,218 /// or in textual repr: collectionSponsor()219 function collectionSponsor() external view returns (EthCrossAccount memory);220221 /// Get current collection limits.222 ///223 /// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:224 /// "accountTokenOwnershipLimit",225 /// "sponsoredDataSize",226 /// "sponsoredDataRateLimit",227 /// "tokenLimit",228 /// "sponsorTransferTimeout",229 /// "sponsorApproveTimeout"230 /// "ownerCanTransfer",231 /// "ownerCanDestroy",232 /// "transfersEnabled"233 /// Return `false` if a limit not set.234 /// @dev EVM selector for this function is: 0xf63bc572,235 /// or in textual repr: collectionLimits()236 function collectionLimits() external view returns (Tuple29[] memory);237238 /// Set limits for the collection.239 /// @dev Throws error if limit not found.240 /// @param limit Name of the limit. Valid names:241 /// "accountTokenOwnershipLimit",242 /// "sponsoredDataSize",243 /// "sponsoredDataRateLimit",244 /// "tokenLimit",245 /// "sponsorTransferTimeout",246 /// "sponsorApproveTimeout"247 /// "ownerCanTransfer",248 /// "ownerCanDestroy",249 /// "transfersEnabled"250 /// @param status enable\disable limit. Works only with `true`.251 /// @param value Value of the limit.252 /// @dev EVM selector for this function is: 0x88150bd0,253 /// or in textual repr: setCollectionLimit(uint8,bool,uint256)254 function setCollectionLimit(255 CollectionLimits limit,256 bool status,257 uint256 value258 ) external;259260 /// Get contract address.261 /// @dev EVM selector for this function is: 0xf6b4dfb4,262 /// or in textual repr: contractAddress()263 function contractAddress() external view returns (address);264265 /// Add collection admin.266 /// @param newAdmin Cross account administrator address.267 /// @dev EVM selector for this function is: 0x859aa7d6,268 /// or in textual repr: addCollectionAdminCross((address,uint256))269 function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;270271 /// Remove collection admin.272 /// @param admin Cross account administrator address.273 /// @dev EVM selector for this function is: 0x6c0cd173,274 /// or in textual repr: removeCollectionAdminCross((address,uint256))275 function removeCollectionAdminCross(EthCrossAccount memory admin) external;276277 // /// Add collection admin.278 // /// @param newAdmin Address of the added administrator.279 // /// @dev EVM selector for this function is: 0x92e462c7,280 // /// or in textual repr: addCollectionAdmin(address)281 // function addCollectionAdmin(address newAdmin) external;282283 // /// Remove collection admin.284 // ///285 // /// @param admin Address of the removed administrator.286 // /// @dev EVM selector for this function is: 0xfafd7b42,287 // /// or in textual repr: removeCollectionAdmin(address)288 // function removeCollectionAdmin(address admin) external;289290 /// Toggle accessibility of collection nesting.291 ///292 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'293 /// @dev EVM selector for this function is: 0x112d4586,294 /// or in textual repr: setCollectionNesting(bool)295 function setCollectionNesting(bool enable) external;296297 /// Toggle accessibility of collection nesting.298 ///299 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'300 /// @param collections Addresses of collections that will be available for nesting.301 /// @dev EVM selector for this function is: 0x64872396,302 /// or in textual repr: setCollectionNesting(bool,address[])303 function setCollectionNesting(bool enable, address[] memory collections) external;304305 /// Returns nesting for a collection306 /// @dev EVM selector for this function is: 0x22d25bfe,307 /// or in textual repr: collectionNestingRestrictedCollectionIds()308<<<<<<< HEAD309 function collectionNestingRestrictedCollectionIds() external view returns (Tuple34 memory);310=======311 function collectionNestingRestrictedCollectionIds() external view returns (Tuple31 memory);312>>>>>>> 09f69700... chore: generate stubs313314 /// Returns permissions for a collection315 /// @dev EVM selector for this function is: 0x5b2eaf4b,316 /// or in textual repr: collectionNestingPermissions()317<<<<<<< HEAD318 function collectionNestingPermissions() external view returns (Tuple37[] memory);319=======320 function collectionNestingPermissions() external view returns (Tuple34[] memory);321>>>>>>> 09f69700... chore: generate stubs322323 /// 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) external;330331 /// Checks that user allowed to operate with collection.332 ///333 /// @param user User address to check.334 /// @dev EVM selector for this function is: 0x91b6df49,335 /// or in textual repr: allowlistedCross((address,uint256))336 function allowlistedCross(EthCrossAccount memory user) external view returns (bool);337338 // /// Add the user to the allowed list.339 // ///340 // /// @param user Address of a trusted user.341 // /// @dev EVM selector for this function is: 0x67844fe6,342 // /// or in textual repr: addToCollectionAllowList(address)343 // function addToCollectionAllowList(address user) external;344345 /// Add user to allowed list.346 ///347 /// @param user User cross account address.348 /// @dev EVM selector for this function is: 0xa0184a3a,349 /// or in textual repr: addToCollectionAllowListCross((address,uint256))350 function addToCollectionAllowListCross(EthCrossAccount memory user) external;351352 // /// Remove the user from the allowed list.353 // ///354 // /// @param user Address of a removed user.355 // /// @dev EVM selector for this function is: 0x85c51acb,356 // /// or in textual repr: removeFromCollectionAllowList(address)357 // function removeFromCollectionAllowList(address user) external;358359 /// Remove user from allowed list.360 ///361 /// @param user User cross account address.362 /// @dev EVM selector for this function is: 0x09ba452a,363 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))364 function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;365366 /// Switch permission for minting.367 ///368 /// @param mode Enable if "true".369 /// @dev EVM selector for this function is: 0x00018e84,370 /// or in textual repr: setCollectionMintMode(bool)371 function setCollectionMintMode(bool mode) external;372373 // /// Check that account is the owner or admin of the collection374 // ///375 // /// @param user account to verify376 // /// @return "true" if account is the owner or admin377 // /// @dev EVM selector for this function is: 0x9811b0c7,378 // /// or in textual repr: isOwnerOrAdmin(address)379 // function isOwnerOrAdmin(address user) external view returns (bool);380381 /// Check that account is the owner or admin of the collection382 ///383 /// @param user User cross account to verify384 /// @return "true" if account is the owner or admin385 /// @dev EVM selector for this function is: 0x3e75a905,386 /// or in textual repr: isOwnerOrAdminCross((address,uint256))387 function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);388389 /// Returns collection type390 ///391 /// @return `Fungible` or `NFT` or `ReFungible`392 /// @dev EVM selector for this function is: 0xd34b55b8,393 /// or in textual repr: uniqueCollectionType()394 function uniqueCollectionType() external view returns (string memory);395396 /// Get collection owner.397 ///398 /// @return Tuble with sponsor address and his substrate mirror.399 /// If address is canonical then substrate mirror is zero and vice versa.400 /// @dev EVM selector for this function is: 0xdf727d3b,401 /// or in textual repr: collectionOwner()402 function collectionOwner() external view returns (EthCrossAccount memory);403404 // /// Changes collection owner to another account405 // ///406 // /// @dev Owner can be changed only by current owner407 // /// @param newOwner new owner account408 // /// @dev EVM selector for this function is: 0x4f53e226,409 // /// or in textual repr: changeCollectionOwner(address)410 // function changeCollectionOwner(address newOwner) external;411412 /// Get collection administrators413 ///414 /// @return Vector of tuples with admins address and his substrate mirror.415 /// If address is canonical then substrate mirror is zero and vice versa.416 /// @dev EVM selector for this function is: 0x5813216b,417 /// or in textual repr: collectionAdmins()418 function collectionAdmins() external view returns (EthCrossAccount[] memory);419420 /// Changes collection owner to another account421 ///422 /// @dev Owner can be changed only by current owner423 /// @param newOwner new owner cross account424 /// @dev EVM selector for this function is: 0x6496c497,425 /// or in textual repr: changeCollectionOwnerCross((address,uint256))426 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) external;427}428429/// @dev Cross account struct430struct EthCrossAccount {431 address eth;432 uint256 sub;433}434435/// @dev anonymous struct436<<<<<<< HEAD437struct Tuple37 {438=======439struct Tuple34 {440>>>>>>> 09f69700... chore: generate stubs441 CollectionPermissions field_0;442 bool field_1;443}444445enum CollectionPermissions {446 CollectionAdmin,447 TokenOwner448}449450/// @dev anonymous struct451<<<<<<< HEAD452struct Tuple34 {453=======454struct Tuple31 {455>>>>>>> 09f69700... chore: generate stubs456 bool field_0;457 uint256[] field_1;458}459460<<<<<<< HEAD461/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.462enum CollectionLimits {463 /// @dev How many tokens can a user have on one account.464 AccountTokenOwnership,465 /// @dev How many bytes of data are available for sponsorship.466 SponsoredDataSize,467 /// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]468 SponsoredDataRateLimit,469 /// @dev How many tokens can be mined into this collection.470 TokenLimit,471 /// @dev Timeouts for transfer sponsoring.472 SponsorTransferTimeout,473 /// @dev Timeout for sponsoring an approval in passed blocks.474 SponsorApproveTimeout,475 /// @dev Whether the collection owner of the collection can send tokens (which belong to other users).476 OwnerCanTransfer,477 /// @dev Can the collection owner burn other people's tokens.478 OwnerCanDestroy,479 /// @dev Is it possible to send tokens from this collection between users.480 TransferEnabled481}482483/// @dev anonymous struct484struct Tuple29 {485 CollectionLimits field_0;486 bool field_1;487 uint256 field_2;488}489490/// @dev anonymous struct491struct Tuple26 {492 address field_0;493 uint256 field_1;494}495496=======497>>>>>>> 0bf15e6f... fixed tests&tuple instead of struct, refactored `refungible` pallet498=======499>>>>>>> 09f69700... chore: generate stubs500/// @dev the ERC-165 identifier for this interface is 0x5b5e139f501interface ERC721Metadata is Dummy, ERC165 {502 // /// @notice A descriptive name for a collection of NFTs in this contract503 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`504 // /// @dev EVM selector for this function is: 0x06fdde03,505 // /// or in textual repr: name()506 // function name() external view returns (string memory);507508 // /// @notice An abbreviated name for NFTs in this contract509 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`510 // /// @dev EVM selector for this function is: 0x95d89b41,511 // /// or in textual repr: symbol()512 // function symbol() external view returns (string memory);513514 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.515 ///516 /// @dev If the token has a `url` property and it is not empty, it is returned.517 /// 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`.518 /// If the collection property `baseURI` is empty or absent, return "" (empty string)519 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix520 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).521 ///522 /// @return token's const_metadata523 /// @dev EVM selector for this function is: 0xc87b56dd,524 /// or in textual repr: tokenURI(uint256)525 function tokenURI(uint256 tokenId) external view returns (string memory);526}527528/// @title ERC721 Token that can be irreversibly burned (destroyed).529/// @dev the ERC-165 identifier for this interface is 0x42966c68530interface ERC721Burnable is Dummy, ERC165 {531 /// @notice Burns a specific ERC721 token.532 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized533 /// operator of the current owner.534 /// @param tokenId The RFT to approve535 /// @dev EVM selector for this function is: 0x42966c68,536 /// or in textual repr: burn(uint256)537 function burn(uint256 tokenId) external;538}539540/// @dev inlined interface541interface ERC721UniqueMintableEvents {542 event MintingFinished();543}544545/// @title ERC721 minting logic.546/// @dev the ERC-165 identifier for this interface is 0x476ff149547interface ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {548 /// @dev EVM selector for this function is: 0x05d2035b,549 /// or in textual repr: mintingFinished()550 function mintingFinished() external view returns (bool);551552 /// @notice Function to mint a token.553 /// @param to The new owner554 /// @return uint256 The id of the newly minted token555 /// @dev EVM selector for this function is: 0x6a627842,556 /// or in textual repr: mint(address)557 function mint(address to) external returns (uint256);558559 // /// @notice Function to mint a token.560 // /// @dev `tokenId` should be obtained with `nextTokenId` method,561 // /// unlike standard, you can't specify it manually562 // /// @param to The new owner563 // /// @param tokenId ID of the minted RFT564 // /// @dev EVM selector for this function is: 0x40c10f19,565 // /// or in textual repr: mint(address,uint256)566 // function mint(address to, uint256 tokenId) external returns (bool);567568 /// @notice Function to mint token with the given tokenUri.569 /// @param to The new owner570 /// @param tokenUri Token URI that would be stored in the NFT properties571 /// @return uint256 The id of the newly minted token572 /// @dev EVM selector for this function is: 0x45c17782,573 /// or in textual repr: mintWithTokenURI(address,string)574 function mintWithTokenURI(address to, string memory tokenUri) external returns (uint256);575576 // /// @notice Function to mint token with the given tokenUri.577 // /// @dev `tokenId` should be obtained with `nextTokenId` method,578 // /// unlike standard, you can't specify it manually579 // /// @param to The new owner580 // /// @param tokenId ID of the minted RFT581 // /// @param tokenUri Token URI that would be stored in the RFT properties582 // /// @dev EVM selector for this function is: 0x50bb4e7f,583 // /// or in textual repr: mintWithTokenURI(address,uint256,string)584 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) external returns (bool);585586 /// @dev Not implemented587 /// @dev EVM selector for this function is: 0x7d64bcb4,588 /// or in textual repr: finishMinting()589 function finishMinting() external returns (bool);590}591592/// @title Unique extensions for ERC721.593/// @dev the ERC-165 identifier for this interface is 0xabf30dc2594interface ERC721UniqueExtensions is Dummy, ERC165 {595 /// @notice A descriptive name for a collection of NFTs in this contract596 /// @dev EVM selector for this function is: 0x06fdde03,597 /// or in textual repr: name()598 function name() external view returns (string memory);599600 /// @notice An abbreviated name for NFTs in this contract601 /// @dev EVM selector for this function is: 0x95d89b41,602 /// or in textual repr: symbol()603 function symbol() external view returns (string memory);604605 /// @notice A description for the collection.606 /// @dev EVM selector for this function is: 0x7284e416,607 /// or in textual repr: description()608 function description() external view returns (string memory);609610 /// Returns the owner (in cross format) of the token.611 ///612 /// @param tokenId Id for the token.613 /// @dev EVM selector for this function is: 0x2b29dace,614 /// or in textual repr: crossOwnerOf(uint256)615 function crossOwnerOf(uint256 tokenId) external view returns (EthCrossAccount memory);616617 /// Returns the token properties.618 ///619 /// @param tokenId Id for the token.620 /// @param keys Properties keys. Empty keys for all propertyes.621 /// @return Vector of properties key/value pairs.622 /// @dev EVM selector for this function is: 0xe07ede7e,623 /// or in textual repr: properties(uint256,string[])624 function properties(uint256 tokenId, string[] memory keys) external view returns (Property[] memory);625626 /// @notice Transfer ownership of an RFT627 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`628 /// is the zero address. Throws if `tokenId` is not a valid RFT.629 /// Throws if RFT pieces have multiple owners.630 /// @param to The new owner631 /// @param tokenId The RFT to transfer632 /// @dev EVM selector for this function is: 0xa9059cbb,633 /// or in textual repr: transfer(address,uint256)634 function transfer(address to, uint256 tokenId) external;635636 /// @notice Transfer ownership of an RFT637 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`638 /// is the zero address. Throws if `tokenId` is not a valid RFT.639 /// Throws if RFT pieces have multiple owners.640 /// @param to The new owner641 /// @param tokenId The RFT to transfer642 /// @dev EVM selector for this function is: 0x2ada85ff,643 /// or in textual repr: transferCross((address,uint256),uint256)644 function transferCross(EthCrossAccount memory to, uint256 tokenId) external;645646 /// @notice Transfer ownership of an RFT647 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`648 /// is the zero address. Throws if `tokenId` is not a valid RFT.649 /// Throws if RFT pieces have multiple owners.650 /// @param to The new owner651 /// @param tokenId The RFT to transfer652 /// @dev EVM selector for this function is: 0xd5cf430b,653 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)654 function transferFromCross(655 EthCrossAccount memory from,656 EthCrossAccount memory to,657 uint256 tokenId658 ) external;659660 // /// @notice Burns a specific ERC721 token.661 // /// @dev Throws unless `msg.sender` is the current owner or an authorized662 // /// operator for this RFT. Throws if `from` is not the current owner. Throws663 // /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.664 // /// Throws if RFT pieces have multiple owners.665 // /// @param from The current owner of the RFT666 // /// @param tokenId The RFT to transfer667 // /// @dev EVM selector for this function is: 0x79cc6790,668 // /// or in textual repr: burnFrom(address,uint256)669 // function burnFrom(address from, uint256 tokenId) external;670671 /// @notice Burns a specific ERC721 token.672 /// @dev Throws unless `msg.sender` is the current owner or an authorized673 /// operator for this RFT. Throws if `from` is not the current owner. Throws674 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.675 /// Throws if RFT pieces have multiple owners.676 /// @param from The current owner of the RFT677 /// @param tokenId The RFT to transfer678 /// @dev EVM selector for this function is: 0xbb2f5a58,679 /// or in textual repr: burnFromCross((address,uint256),uint256)680 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;681682 /// @notice Returns next free RFT ID.683 /// @dev EVM selector for this function is: 0x75794a3c,684 /// or in textual repr: nextTokenId()685 function nextTokenId() external view returns (uint256);686687 // /// @notice Function to mint multiple tokens.688 // /// @dev `tokenIds` should be an array of consecutive numbers and first number689 // /// should be obtained with `nextTokenId` method690 // /// @param to The new owner691 // /// @param tokenIds IDs of the minted RFTs692 // /// @dev EVM selector for this function is: 0x44a9945e,693 // /// or in textual repr: mintBulk(address,uint256[])694 // function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);695696 // /// @notice Function to mint multiple tokens with the given tokenUris.697 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive698 // /// numbers and first number should be obtained with `nextTokenId` method699 // /// @param to The new owner700 // /// @param tokens array of pairs of token ID and token URI for minted tokens701 // /// @dev EVM selector for this function is: 0x36543006,702 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])703 // function mintBulkWithTokenURI(address to, Tuple12[] memory tokens) external returns (bool);704705 /// @notice Function to mint a token.706 /// @param to The new owner crossAccountId707 /// @param properties Properties of minted token708 /// @return uint256 The id of the newly minted token709 /// @dev EVM selector for this function is: 0xb904db03,710 /// or in textual repr: mintCross((address,uint256),(string,bytes)[])711 function mintCross(EthCrossAccount memory to, Property[] memory properties) external returns (uint256);712713 /// Returns EVM address for refungible token714 ///715 /// @param token ID of the token716 /// @dev EVM selector for this function is: 0xab76fac6,717 /// or in textual repr: tokenContractAddress(uint256)718 function tokenContractAddress(uint256 token) external view returns (address);719}720721/// @dev anonymous struct722struct Tuple12 {723 uint256 field_0;724 string field_1;725}726727/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension728/// @dev See https://eips.ethereum.org/EIPS/eip-721729/// @dev the ERC-165 identifier for this interface is 0x780e9d63730interface ERC721Enumerable is Dummy, ERC165 {731 /// @notice Enumerate valid RFTs732 /// @param index A counter less than `totalSupply()`733 /// @return The token identifier for the `index`th NFT,734 /// (sort order not specified)735 /// @dev EVM selector for this function is: 0x4f6ccce7,736 /// or in textual repr: tokenByIndex(uint256)737 function tokenByIndex(uint256 index) external view returns (uint256);738739 /// Not implemented740 /// @dev EVM selector for this function is: 0x2f745c59,741 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)742 function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);743744 /// @notice Count RFTs tracked by this contract745 /// @return A count of valid RFTs tracked by this contract, where each one of746 /// them has an assigned and queryable owner not equal to the zero address747 /// @dev EVM selector for this function is: 0x18160ddd,748 /// or in textual repr: totalSupply()749 function totalSupply() external view returns (uint256);750}751752/// @dev inlined interface753interface ERC721Events {754 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);755 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);756 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);757}758759/// @title ERC-721 Non-Fungible Token Standard760/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md761/// @dev the ERC-165 identifier for this interface is 0x4016cd87762interface ERC721 is Dummy, ERC165, ERC721Events {763 /// @notice Count all RFTs assigned to an owner764 /// @dev RFTs assigned to the zero address are considered invalid, and this765 /// function throws for queries about the zero address.766 /// @param owner An address for whom to query the balance767 /// @return The number of RFTs owned by `owner`, possibly zero768 /// @dev EVM selector for this function is: 0x70a08231,769 /// or in textual repr: balanceOf(address)770 function balanceOf(address owner) external view returns (uint256);771772 /// @notice Find the owner of an RFT773 /// @dev RFTs assigned to zero address are considered invalid, and queries774 /// about them do throw.775 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for776 /// the tokens that are partially owned.777 /// @param tokenId The identifier for an RFT778 /// @return The address of the owner of the RFT779 /// @dev EVM selector for this function is: 0x6352211e,780 /// or in textual repr: ownerOf(uint256)781 function ownerOf(uint256 tokenId) external view returns (address);782783 /// @dev Not implemented784 /// @dev EVM selector for this function is: 0x60a11672,785 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)786 function safeTransferFromWithData(787 address from,788 address to,789 uint256 tokenId,790 bytes memory data791 ) external;792793 /// @dev Not implemented794 /// @dev EVM selector for this function is: 0x42842e0e,795 /// or in textual repr: safeTransferFrom(address,address,uint256)796 function safeTransferFrom(797 address from,798 address to,799 uint256 tokenId800 ) external;801802 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE803 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE804 /// THEY MAY BE PERMANENTLY LOST805 /// @dev Throws unless `msg.sender` is the current owner or an authorized806 /// operator for this RFT. Throws if `from` is not the current owner. Throws807 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.808 /// Throws if RFT pieces have multiple owners.809 /// @param from The current owner of the NFT810 /// @param to The new owner811 /// @param tokenId The NFT to transfer812 /// @dev EVM selector for this function is: 0x23b872dd,813 /// or in textual repr: transferFrom(address,address,uint256)814 function transferFrom(815 address from,816 address to,817 uint256 tokenId818 ) external;819820 /// @dev Not implemented821 /// @dev EVM selector for this function is: 0x095ea7b3,822 /// or in textual repr: approve(address,uint256)823 function approve(address approved, uint256 tokenId) external;824825 /// @notice Sets or unsets the approval of a given operator.826 /// The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.827 /// @param operator Operator828 /// @param approved Should operator status be granted or revoked?829 /// @dev EVM selector for this function is: 0xa22cb465,830 /// or in textual repr: setApprovalForAll(address,bool)831 function setApprovalForAll(address operator, bool approved) external;832833 /// @dev Not implemented834 /// @dev EVM selector for this function is: 0x081812fc,835 /// or in textual repr: getApproved(uint256)836 function getApproved(uint256 tokenId) external view returns (address);837838 /// @notice Tells whether the given `owner` approves the `operator`.839 /// @dev EVM selector for this function is: 0xe985e9c5,840 /// or in textual repr: isApprovedForAll(address,address)841 function isApprovedForAll(address owner, address operator) external view returns (bool);842843 /// @notice Returns collection helper contract address844 /// @dev EVM selector for this function is: 0x1896cce6,845 /// or in textual repr: collectionHelperAddress()846 function collectionHelperAddress() external view returns (address);847}848849interface UniqueRefungible is850 Dummy,851 ERC165,852 ERC721,853 ERC721Enumerable,854 ERC721UniqueExtensions,855 ERC721UniqueMintable,856 ERC721Burnable,857 ERC721Metadata,858 Collection,859 TokenProperties860{}