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 0x55dba91917interface 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(27 string memory key,28 bool isMutable,29 bool collectionAdmin,30 bool tokenOwner31 ) external;3233 /// @notice Set token property value.34 /// @dev Throws error if `msg.sender` has no permission to edit the property.35 /// @param tokenId ID of the token.36 /// @param key Property key.37 /// @param value Property value.38 /// @dev EVM selector for this function is: 0x1752d67b,39 /// or in textual repr: setProperty(uint256,string,bytes)40 function setProperty(41 uint256 tokenId,42 string memory key,43 bytes memory value44 ) external;4546 /// @notice Set token properties value.47 /// @dev Throws error if `msg.sender` has no permission to edit the property.48 /// @param tokenId ID of the token.49 /// @param properties settable properties50 /// @dev EVM selector for this function is: 0x14ed3a6e,51 /// or in textual repr: setProperties(uint256,(string,bytes)[])52 function setProperties(uint256 tokenId, Tuple19[] memory properties) external;5354 /// @notice Delete token property value.55 /// @dev Throws error if `msg.sender` has no permission to edit the property.56 /// @param tokenId ID of the token.57 /// @param key Property key.58 /// @dev EVM selector for this function is: 0x066111d1,59 /// or in textual repr: deleteProperty(uint256,string)60 function deleteProperty(uint256 tokenId, string memory key) external;6162 /// @notice Get token property value.63 /// @dev Throws error if key not found64 /// @param tokenId ID of the token.65 /// @param key Property key.66 /// @return Property value bytes67 /// @dev EVM selector for this function is: 0x7228c327,68 /// or in textual repr: property(uint256,string)69 function property(uint256 tokenId, string memory key) external view returns (bytes memory);70}7172/// @title A contract that allows you to work with collections.73/// @dev the ERC-165 identifier for this interface is 0xb3152af374interface Collection is Dummy, ERC165 {75 /// Set collection property.76 ///77 /// @param key Property key.78 /// @param value Propery value.79 /// @dev EVM selector for this function is: 0x2f073f66,80 /// or in textual repr: setCollectionProperty(string,bytes)81 function setCollectionProperty(string memory key, bytes memory value) external;8283 /// Set collection properties.84 ///85 /// @param properties Vector of properties key/value pair.86 /// @dev EVM selector for this function is: 0x50b26b2a,87 /// or in textual repr: setCollectionProperties((string,bytes)[])88 function setCollectionProperties(Tuple20[] memory properties) external;8990 /// Delete collection property.91 ///92 /// @param key Property key.93 /// @dev EVM selector for this function is: 0x7b7debce,94 /// or in textual repr: deleteCollectionProperty(string)95 function deleteCollectionProperty(string memory key) external;9697 /// Delete collection properties.98 ///99 /// @param keys Properties keys.100 /// @dev EVM selector for this function is: 0xee206ee3,101 /// or in textual repr: deleteCollectionProperties(string[])102 function deleteCollectionProperties(string[] memory keys) external;103104 /// Get collection property.105 ///106 /// @dev Throws error if key not found.107 ///108 /// @param key Property key.109 /// @return bytes The property corresponding to the key.110 /// @dev EVM selector for this function is: 0xcf24fd6d,111 /// or in textual repr: collectionProperty(string)112 function collectionProperty(string memory key) external view returns (bytes memory);113114 /// Get collection properties.115 ///116 /// @param keys Properties keys. Empty keys for all propertyes.117 /// @return Vector of properties key/value pairs.118 /// @dev EVM selector for this function is: 0x285fb8e6,119 /// or in textual repr: collectionProperties(string[])120 function collectionProperties(string[] memory keys) external view returns (Tuple20[] memory);121122 /// Set the sponsor of the collection.123 ///124 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.125 ///126 /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.127 /// @dev EVM selector for this function is: 0x7623402e,128 /// or in textual repr: setCollectionSponsor(address)129 function setCollectionSponsor(address sponsor) external;130131 /// Set the sponsor of the collection.132 ///133 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.134 ///135 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.136 /// @dev EVM selector for this function is: 0x84a1d5a8,137<<<<<<< HEAD138 /// or in textual repr: setCollectionSponsorCross((address,uint256))139 function setCollectionSponsorCross(Tuple6 memory sponsor) external;140=======141 /// or in textual repr: setCollectionSponsorCross(EthCrossAccount)142 /// or in the expanded repr: setCollectionSponsorCross((address,uint256))143 function setCollectionSponsorCross(EthCrossAccount memory sponsor) external;144>>>>>>> misk: update stubs145146 /// Whether there is a pending sponsor.147 /// @dev EVM selector for this function is: 0x058ac185,148 /// or in textual repr: hasCollectionPendingSponsor()149 function hasCollectionPendingSponsor() external view returns (bool);150151 /// Collection sponsorship confirmation.152 ///153 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.154 /// @dev EVM selector for this function is: 0x3c50e97a,155 /// or in textual repr: confirmCollectionSponsorship()156 function confirmCollectionSponsorship() external;157158 /// Remove collection sponsor.159 /// @dev EVM selector for this function is: 0x6e0326a3,160 /// or in textual repr: removeCollectionSponsor()161 function removeCollectionSponsor() external;162163 /// Get current sponsor.164 ///165 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.166 /// @dev EVM selector for this function is: 0x6ec0a9f1,167 /// or in textual repr: collectionSponsor()168<<<<<<< HEAD169 function collectionSponsor() external view returns (Tuple6 memory);170=======171 function collectionSponsor() external view returns (Tuple23 memory);172>>>>>>> misk: update stubs173174 /// Set limits for the collection.175 /// @dev Throws error if limit not found.176 /// @param limit Name of the limit. Valid names:177 /// "accountTokenOwnershipLimit",178 /// "sponsoredDataSize",179 /// "sponsoredDataRateLimit",180 /// "tokenLimit",181 /// "sponsorTransferTimeout",182 /// "sponsorApproveTimeout"183 /// @param value Value of the limit.184 /// @dev EVM selector for this function is: 0x6a3841db,185 /// or in textual repr: setCollectionLimit(string,uint32)186 function setCollectionLimit(string memory limit, uint32 value) external;187188 /// Set limits for the collection.189 /// @dev Throws error if limit not found.190 /// @param limit Name of the limit. Valid names:191 /// "ownerCanTransfer",192 /// "ownerCanDestroy",193 /// "transfersEnabled"194 /// @param value Value of the limit.195 /// @dev EVM selector for this function is: 0x993b7fba,196 /// or in textual repr: setCollectionLimit(string,bool)197 function setCollectionLimit(string memory limit, bool value) external;198199 /// Get contract address.200 /// @dev EVM selector for this function is: 0xf6b4dfb4,201 /// or in textual repr: contractAddress()202 function contractAddress() external view returns (address);203204 /// Add collection admin.205 /// @param newAdmin Cross account administrator address.206 /// @dev EVM selector for this function is: 0x859aa7d6,207<<<<<<< HEAD208 /// or in textual repr: addCollectionAdminCross((address,uint256))209 function addCollectionAdminCross(Tuple6 memory newAdmin) external;210=======211 /// or in textual repr: addCollectionAdminCross(EthCrossAccount)212 /// or in the expanded repr: addCollectionAdminCross((address,uint256))213 function addCollectionAdminCross(EthCrossAccount memory newAdmin) external;214>>>>>>> misk: update stubs215216 /// Remove collection admin.217 /// @param admin Cross account administrator address.218 /// @dev EVM selector for this function is: 0x6c0cd173,219<<<<<<< HEAD220 /// or in textual repr: removeCollectionAdminCross((address,uint256))221 function removeCollectionAdminCross(Tuple6 memory admin) external;222=======223 /// or in textual repr: removeCollectionAdminCross(EthCrossAccount)224 /// or in the expanded repr: removeCollectionAdminCross((address,uint256))225 function removeCollectionAdminCross(EthCrossAccount memory admin) external;226>>>>>>> misk: update stubs227228 /// Add collection admin.229 /// @param newAdmin Address of the added administrator.230 /// @dev EVM selector for this function is: 0x92e462c7,231 /// or in textual repr: addCollectionAdmin(address)232 function addCollectionAdmin(address newAdmin) external;233234 /// Remove collection admin.235 ///236 /// @param admin Address of the removed administrator.237 /// @dev EVM selector for this function is: 0xfafd7b42,238 /// or in textual repr: removeCollectionAdmin(address)239 function removeCollectionAdmin(address admin) external;240241 /// Toggle accessibility of collection nesting.242 ///243 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'244 /// @dev EVM selector for this function is: 0x112d4586,245 /// or in textual repr: setCollectionNesting(bool)246 function setCollectionNesting(bool enable) external;247248 /// Toggle accessibility of collection nesting.249 ///250 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'251 /// @param collections Addresses of collections that will be available for nesting.252 /// @dev EVM selector for this function is: 0x64872396,253 /// or in textual repr: setCollectionNesting(bool,address[])254 function setCollectionNesting(bool enable, address[] memory collections) external;255256 /// Set the collection access method.257 /// @param mode Access mode258 /// 0 for Normal259 /// 1 for AllowList260 /// @dev EVM selector for this function is: 0x41835d4c,261 /// or in textual repr: setCollectionAccess(uint8)262 function setCollectionAccess(uint8 mode) external;263264 /// Checks that user allowed to operate with collection.265 ///266 /// @param user User address to check.267 /// @dev EVM selector for this function is: 0xd63a8e11,268 /// or in textual repr: allowed(address)269 function allowed(address user) external view returns (bool);270271 /// Add the user to the allowed list.272 ///273 /// @param user Address of a trusted user.274 /// @dev EVM selector for this function is: 0x67844fe6,275 /// or in textual repr: addToCollectionAllowList(address)276 function addToCollectionAllowList(address user) external;277278 /// Add user to allowed list.279 ///280 /// @param user User cross account address.281 /// @dev EVM selector for this function is: 0xa0184a3a,282<<<<<<< HEAD283 /// or in textual repr: addToCollectionAllowListCross((address,uint256))284 function addToCollectionAllowListCross(Tuple6 memory user) external;285=======286 /// or in textual repr: addToCollectionAllowListCross(EthCrossAccount)287 /// or in the expanded repr: addToCollectionAllowListCross((address,uint256))288 function addToCollectionAllowListCross(EthCrossAccount memory user) external;289>>>>>>> misk: update stubs290291 /// Remove the user from the allowed list.292 ///293 /// @param user Address of a removed user.294 /// @dev EVM selector for this function is: 0x85c51acb,295 /// or in textual repr: removeFromCollectionAllowList(address)296 function removeFromCollectionAllowList(address user) external;297298 /// Remove user from allowed list.299 ///300 /// @param user User cross account address.301 /// @dev EVM selector for this function is: 0x09ba452a,302<<<<<<< HEAD303 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))304 function removeFromCollectionAllowListCross(Tuple6 memory user) external;305=======306 /// or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)307 /// or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))308 function removeFromCollectionAllowListCross(EthCrossAccount memory user) external;309>>>>>>> misk: update stubs310311 /// Switch permission for minting.312 ///313 /// @param mode Enable if "true".314 /// @dev EVM selector for this function is: 0x00018e84,315 /// or in textual repr: setCollectionMintMode(bool)316 function setCollectionMintMode(bool mode) external;317318 /// Check that account is the owner or admin of the collection319 ///320 /// @param user account to verify321 /// @return "true" if account is the owner or admin322 /// @dev EVM selector for this function is: 0x9811b0c7,323 /// or in textual repr: isOwnerOrAdmin(address)324 function isOwnerOrAdmin(address user) external view returns (bool);325326 /// Check that account is the owner or admin of the collection327 ///328 /// @param user User cross account to verify329 /// @return "true" if account is the owner or admin330 /// @dev EVM selector for this function is: 0x3e75a905,331<<<<<<< HEAD332 /// or in textual repr: isOwnerOrAdminCross((address,uint256))333 function isOwnerOrAdminCross(Tuple6 memory user) external view returns (bool);334=======335 /// or in textual repr: isOwnerOrAdminCross(EthCrossAccount)336 /// or in the expanded repr: isOwnerOrAdminCross((address,uint256))337 function isOwnerOrAdminCross(EthCrossAccount memory user) external view returns (bool);338>>>>>>> misk: update stubs339340 /// Returns collection type341 ///342 /// @return `Fungible` or `NFT` or `ReFungible`343 /// @dev EVM selector for this function is: 0xd34b55b8,344 /// or in textual repr: uniqueCollectionType()345 function uniqueCollectionType() external view returns (string memory);346347 /// Get collection owner.348 ///349 /// @return Tuple with sponsor address and his substrate mirror.350 /// If address is canonical then substrate mirror is zero and vice versa.351 /// @dev EVM selector for this function is: 0xdf727d3b,352 /// or in textual repr: collectionOwner()353<<<<<<< HEAD354 function collectionOwner() external view returns (Tuple6 memory);355=======356 function collectionOwner() external view returns (EthCrossAccount memory);357>>>>>>> misk: update stubs358359 /// Changes collection owner to another account360 ///361 /// @dev Owner can be changed only by current owner362 /// @param newOwner new owner account363 /// @dev EVM selector for this function is: 0x4f53e226,364 /// or in textual repr: changeCollectionOwner(address)365 function changeCollectionOwner(address newOwner) external;366367 /// Get collection administrators368 ///369 /// @return Vector of tuples with admins address and his substrate mirror.370 /// If address is canonical then substrate mirror is zero and vice versa.371 /// @dev EVM selector for this function is: 0x5813216b,372 /// or in textual repr: collectionAdmins()373<<<<<<< HEAD374 function collectionAdmins() external view returns (Tuple6[] memory);375=======376 function collectionAdmins() external view returns (EthCrossAccount[] memory);377>>>>>>> misk: update stubs378379 /// Changes collection owner to another account380 ///381 /// @dev Owner can be changed only by current owner382 /// @param newOwner new owner cross account383 /// @dev EVM selector for this function is: 0xe5c9913f,384<<<<<<< HEAD385 /// or in textual repr: setOwnerCross((address,uint256))386 function setOwnerCross(Tuple6 memory newOwner) external;387=======388 /// or in textual repr: setOwnerCross(EthCrossAccount)389 /// or in the expanded repr: setOwnerCross((address,uint256))390 function setOwnerCross(EthCrossAccount memory newOwner) external;391}392393/// @dev Cross account struct394struct EthCrossAccount {395 address eth;396 uint256 sub;397}398399/// @dev anonymous struct400struct Tuple23 {401 address field_0;402 uint256 field_1;403>>>>>>> misk: update stubs404}405406/// @dev anonymous struct407struct Tuple20 {408 string field_0;409 bytes field_1;410}411412/// @dev the ERC-165 identifier for this interface is 0x5b5e139f413interface ERC721Metadata is Dummy, ERC165 {414 // /// @notice A descriptive name for a collection of NFTs in this contract415 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`416 // /// @dev EVM selector for this function is: 0x06fdde03,417 // /// or in textual repr: name()418 // function name() external view returns (string memory);419420 // /// @notice An abbreviated name for NFTs in this contract421 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`422 // /// @dev EVM selector for this function is: 0x95d89b41,423 // /// or in textual repr: symbol()424 // function symbol() external view returns (string memory);425426 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.427 ///428 /// @dev If the token has a `url` property and it is not empty, it is returned.429 /// 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`.430 /// If the collection property `baseURI` is empty or absent, return "" (empty string)431 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix432 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).433 ///434 /// @return token's const_metadata435 /// @dev EVM selector for this function is: 0xc87b56dd,436 /// or in textual repr: tokenURI(uint256)437 function tokenURI(uint256 tokenId) external view returns (string memory);438}439440/// @title ERC721 Token that can be irreversibly burned (destroyed).441/// @dev the ERC-165 identifier for this interface is 0x42966c68442interface ERC721Burnable is Dummy, ERC165 {443 /// @notice Burns a specific ERC721 token.444 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized445 /// operator of the current owner.446 /// @param tokenId The RFT to approve447 /// @dev EVM selector for this function is: 0x42966c68,448 /// or in textual repr: burn(uint256)449 function burn(uint256 tokenId) external;450}451452/// @dev inlined interface453interface ERC721UniqueMintableEvents {454 event MintingFinished();455}456457/// @title ERC721 minting logic.458/// @dev the ERC-165 identifier for this interface is 0x476ff149459interface ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {460 /// @dev EVM selector for this function is: 0x05d2035b,461 /// or in textual repr: mintingFinished()462 function mintingFinished() external view returns (bool);463464 /// @notice Function to mint token.465 /// @param to The new owner466 /// @return uint256 The id of the newly minted token467 /// @dev EVM selector for this function is: 0x6a627842,468 /// or in textual repr: mint(address)469 function mint(address to) external returns (uint256);470471 // /// @notice Function to mint token.472 // /// @dev `tokenId` should be obtained with `nextTokenId` method,473 // /// unlike standard, you can't specify it manually474 // /// @param to The new owner475 // /// @param tokenId ID of the minted RFT476 // /// @dev EVM selector for this function is: 0x40c10f19,477 // /// or in textual repr: mint(address,uint256)478 // function mint(address to, uint256 tokenId) external returns (bool);479480 /// @notice Function to mint token with the given tokenUri.481 /// @param to The new owner482 /// @param tokenUri Token URI that would be stored in the NFT properties483 /// @return uint256 The id of the newly minted token484 /// @dev EVM selector for this function is: 0x45c17782,485 /// or in textual repr: mintWithTokenURI(address,string)486 function mintWithTokenURI(address to, string memory tokenUri) external returns (uint256);487488 // /// @notice Function to mint token with the given tokenUri.489 // /// @dev `tokenId` should be obtained with `nextTokenId` method,490 // /// unlike standard, you can't specify it manually491 // /// @param to The new owner492 // /// @param tokenId ID of the minted RFT493 // /// @param tokenUri Token URI that would be stored in the RFT properties494 // /// @dev EVM selector for this function is: 0x50bb4e7f,495 // /// or in textual repr: mintWithTokenURI(address,uint256,string)496 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) external returns (bool);497498 /// @dev Not implemented499 /// @dev EVM selector for this function is: 0x7d64bcb4,500 /// or in textual repr: finishMinting()501 function finishMinting() external returns (bool);502}503504/// @title Unique extensions for ERC721.505/// @dev the ERC-165 identifier for this interface is 0x81feb398506interface ERC721UniqueExtensions is Dummy, ERC165 {507 /// @notice A descriptive name for a collection of NFTs in this contract508 /// @dev EVM selector for this function is: 0x06fdde03,509 /// or in textual repr: name()510 function name() external view returns (string memory);511512 /// @notice An abbreviated name for NFTs in this contract513 /// @dev EVM selector for this function is: 0x95d89b41,514 /// or in textual repr: symbol()515 function symbol() external view returns (string memory);516517 /// @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) external;526527 /// @notice Transfer ownership of an RFT528 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`529 /// is the zero address. Throws if `tokenId` is not a valid RFT.530 /// Throws if RFT pieces have multiple owners.531 /// @param to The new owner532 /// @param tokenId The RFT to transfer533 /// @dev EVM selector for this function is: 0xd5cf430b,534 /// or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)535 /// or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)536 function transferFromCross(537<<<<<<< HEAD538 Tuple6 memory from,539 Tuple6 memory to,540=======541 EthCrossAccount memory from,542 EthCrossAccount memory to,543>>>>>>> misk: update stubs544 uint256 tokenId545 ) external;546547 /// @notice Burns a specific ERC721 token.548 /// @dev Throws unless `msg.sender` is the current owner or an authorized549 /// operator for this RFT. Throws if `from` is not the current owner. Throws550 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.551 /// Throws if RFT pieces have multiple owners.552 /// @param from The current owner of the RFT553 /// @param tokenId The RFT to transfer554 /// @dev EVM selector for this function is: 0x79cc6790,555 /// or in textual repr: burnFrom(address,uint256)556 function burnFrom(address from, uint256 tokenId) external;557558 /// @notice Burns a specific ERC721 token.559 /// @dev Throws unless `msg.sender` is the current owner or an authorized560 /// operator for this RFT. Throws if `from` is not the current owner. Throws561 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.562 /// Throws if RFT pieces have multiple owners.563 /// @param from The current owner of the RFT564 /// @param tokenId The RFT to transfer565 /// @dev EVM selector for this function is: 0xbb2f5a58,566<<<<<<< HEAD567 /// or in textual repr: burnFromCross((address,uint256),uint256)568 function burnFromCross(Tuple6 memory from, uint256 tokenId) external;569=======570 /// or in textual repr: burnFromCross(EthCrossAccount,uint256)571 /// or in the expanded repr: burnFromCross((address,uint256),uint256)572 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) external;573>>>>>>> misk: update stubs574575 /// @notice Returns next free RFT ID.576 /// @dev EVM selector for this function is: 0x75794a3c,577 /// or in textual repr: nextTokenId()578 function nextTokenId() external view returns (uint256);579580<<<<<<< HEAD581 // /// @notice Function to mint multiple tokens.582 // /// @dev `tokenIds` should be an array of consecutive numbers and first number583 // /// should be obtained with `nextTokenId` method584 // /// @param to The new owner585 // /// @param tokenIds IDs of the minted RFTs586 // /// @dev EVM selector for this function is: 0x44a9945e,587 // /// or in textual repr: mintBulk(address,uint256[])588 // function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);589590 // /// @notice Function to mint multiple tokens with the given tokenUris.591 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive592 // /// numbers and first number should be obtained with `nextTokenId` method593 // /// @param to The new owner594 // /// @param tokens array of pairs of token ID and token URI for minted tokens595 // /// @dev EVM selector for this function is: 0x36543006,596 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])597 // function mintBulkWithTokenURI(address to, Tuple8[] memory tokens) external returns (bool);598=======599 /// @notice Function to mint multiple tokens.600 /// @dev `tokenIds` should be an array of consecutive numbers and first number601 /// should be obtained with `nextTokenId` method602 /// @param to The new owner603 /// @param tokenIds IDs of the minted RFTs604 /// @dev EVM selector for this function is: 0x44a9945e,605 /// or in textual repr: mintBulk(address,uint256[])606 function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);607608 /// @notice Function to mint multiple tokens with the given tokenUris.609 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive610 /// numbers and first number should be obtained with `nextTokenId` method611 /// @param to The new owner612 /// @param tokens array of pairs of token ID and token URI for minted tokens613 /// @dev EVM selector for this function is: 0x36543006,614 /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])615 function mintBulkWithTokenURI(address to, Tuple11[] memory tokens) external returns (bool);616>>>>>>> misk: update stubs617618 /// Returns EVM address for refungible token619 ///620 /// @param token ID of the token621 /// @dev EVM selector for this function is: 0xab76fac6,622 /// or in textual repr: tokenContractAddress(uint256)623 function tokenContractAddress(uint256 token) external view returns (address);624}625626/// @dev anonymous struct627<<<<<<< HEAD628struct Tuple8 {629=======630struct Tuple11 {631>>>>>>> misk: update stubs632 uint256 field_0;633 string field_1;634}635636<<<<<<< HEAD637/// @dev anonymous struct638struct Tuple6 {639 address field_0;640 uint256 field_1;641}642643=======644>>>>>>> misk: update stubs645/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension646/// @dev See https://eips.ethereum.org/EIPS/eip-721647/// @dev the ERC-165 identifier for this interface is 0x780e9d63648interface ERC721Enumerable is Dummy, ERC165 {649 /// @notice Enumerate valid RFTs650 /// @param index A counter less than `totalSupply()`651 /// @return The token identifier for the `index`th NFT,652 /// (sort order not specified)653 /// @dev EVM selector for this function is: 0x4f6ccce7,654 /// or in textual repr: tokenByIndex(uint256)655 function tokenByIndex(uint256 index) external view returns (uint256);656657 /// Not implemented658 /// @dev EVM selector for this function is: 0x2f745c59,659 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)660 function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);661662 /// @notice Count RFTs tracked by this contract663 /// @return A count of valid RFTs tracked by this contract, where each one of664 /// them has an assigned and queryable owner not equal to the zero address665 /// @dev EVM selector for this function is: 0x18160ddd,666 /// or in textual repr: totalSupply()667 function totalSupply() external view returns (uint256);668}669670/// @dev inlined interface671interface ERC721Events {672 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);673 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);674 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);675}676677/// @title ERC-721 Non-Fungible Token Standard678/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md679/// @dev the ERC-165 identifier for this interface is 0x58800161680interface ERC721 is Dummy, ERC165, ERC721Events {681 /// @notice Count all RFTs assigned to an owner682 /// @dev RFTs assigned to the zero address are considered invalid, and this683 /// function throws for queries about the zero address.684 /// @param owner An address for whom to query the balance685 /// @return The number of RFTs owned by `owner`, possibly zero686 /// @dev EVM selector for this function is: 0x70a08231,687 /// or in textual repr: balanceOf(address)688 function balanceOf(address owner) external view returns (uint256);689690 /// @notice Find the owner of an RFT691 /// @dev RFTs assigned to zero address are considered invalid, and queries692 /// about them do throw.693 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for694 /// the tokens that are partially owned.695 /// @param tokenId The identifier for an RFT696 /// @return The address of the owner of the RFT697 /// @dev EVM selector for this function is: 0x6352211e,698 /// or in textual repr: ownerOf(uint256)699 function ownerOf(uint256 tokenId) external view returns (address);700701 /// @dev Not implemented702 /// @dev EVM selector for this function is: 0x60a11672,703 /// or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)704 function safeTransferFromWithData(705 address from,706 address to,707 uint256 tokenId,708 bytes memory data709 ) external;710711 /// @dev Not implemented712 /// @dev EVM selector for this function is: 0x42842e0e,713 /// or in textual repr: safeTransferFrom(address,address,uint256)714 function safeTransferFrom(715 address from,716 address to,717 uint256 tokenId718 ) external;719720 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE721 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE722 /// THEY MAY BE PERMANENTLY LOST723 /// @dev Throws unless `msg.sender` is the current owner or an authorized724 /// operator for this RFT. Throws if `from` is not the current owner. Throws725 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.726 /// Throws if RFT pieces have multiple owners.727 /// @param from The current owner of the NFT728 /// @param to The new owner729 /// @param tokenId The NFT to transfer730 /// @dev EVM selector for this function is: 0x23b872dd,731 /// or in textual repr: transferFrom(address,address,uint256)732 function transferFrom(733 address from,734 address to,735 uint256 tokenId736 ) external;737738 /// @dev Not implemented739 /// @dev EVM selector for this function is: 0x095ea7b3,740 /// or in textual repr: approve(address,uint256)741 function approve(address approved, uint256 tokenId) external;742743 /// @dev Not implemented744 /// @dev EVM selector for this function is: 0xa22cb465,745 /// or in textual repr: setApprovalForAll(address,bool)746 function setApprovalForAll(address operator, bool approved) external;747748 /// @dev Not implemented749 /// @dev EVM selector for this function is: 0x081812fc,750 /// or in textual repr: getApproved(uint256)751 function getApproved(uint256 tokenId) external view returns (address);752753 /// @dev Not implemented754 /// @dev EVM selector for this function is: 0xe985e9c5,755 /// or in textual repr: isApprovedForAll(address,address)756 function isApprovedForAll(address owner, address operator) external view returns (address);757}758759interface UniqueRefungible is760 Dummy,761 ERC165,762 ERC721,763 ERC721Enumerable,764 ERC721UniqueExtensions,765 ERC721UniqueMintable,766 ERC721Burnable,767 ERC721Metadata,768 Collection,769 TokenProperties770{}