git.delta.rocks / unique-network / refs/commits / 0c121c74a848

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/// @dev inlined interface16interface ERC721TokenEvent {17	event TokenChanged(uint256 indexed tokenId);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 0xde0695c222interface TokenProperties is Dummy, ERC165, ERC721TokenEvent {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) external;3233	/// @notice Set permissions for token property.34	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.35	/// @param permissions Permissions for keys.36	/// @dev EVM selector for this function is: 0xbd92983a,37	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])38	function setTokenPropertyPermissions(TokenPropertyPermission[] memory permissions) external;3940	/// @notice Get permissions for token properties.41	/// @dev EVM selector for this function is: 0xf23d7790,42	///  or in textual repr: tokenPropertyPermissions()43	function tokenPropertyPermissions() external view returns (TokenPropertyPermission[] memory);4445	// /// @notice Set token property value.46	// /// @dev Throws error if `msg.sender` has no permission to edit the property.47	// /// @param tokenId ID of the token.48	// /// @param key Property key.49	// /// @param value Property value.50	// /// @dev EVM selector for this function is: 0x1752d67b,51	// ///  or in textual repr: setProperty(uint256,string,bytes)52	// function setProperty(uint256 tokenId, string memory key, bytes memory value) external;5354	/// @notice Set token properties value.55	/// @dev Throws error if `msg.sender` has no permission to edit the property.56	/// @param tokenId ID of the token.57	/// @param properties settable properties58	/// @dev EVM selector for this function is: 0x14ed3a6e,59	///  or in textual repr: setProperties(uint256,(string,bytes)[])60	function setProperties(uint256 tokenId, Property[] memory properties) external;6162	// /// @notice Delete token property value.63	// /// @dev Throws error if `msg.sender` has no permission to edit the property.64	// /// @param tokenId ID of the token.65	// /// @param key Property key.66	// /// @dev EVM selector for this function is: 0x066111d1,67	// ///  or in textual repr: deleteProperty(uint256,string)68	// function deleteProperty(uint256 tokenId, string memory key) external;6970	/// @notice Delete token properties value.71	/// @dev Throws error if `msg.sender` has no permission to edit the property.72	/// @param tokenId ID of the token.73	/// @param keys Properties key.74	/// @dev EVM selector for this function is: 0xc472d371,75	///  or in textual repr: deleteProperties(uint256,string[])76	function deleteProperties(uint256 tokenId, string[] memory keys) external;7778	/// @notice Get token property value.79	/// @dev Throws error if key not found80	/// @param tokenId ID of the token.81	/// @param key Property key.82	/// @return Property value bytes83	/// @dev EVM selector for this function is: 0x7228c327,84	///  or in textual repr: property(uint256,string)85	function property(uint256 tokenId, string memory key) external view returns (bytes memory);86}8788/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).89struct Property {90	string key;91	bytes value;92}9394/// Ethereum representation of Token Property Permissions.95struct TokenPropertyPermission {96	/// Token property key.97	string key;98	/// Token property permissions.99	PropertyPermission[] permissions;100}101102/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.103struct PropertyPermission {104	/// TokenPermission field.105	TokenPermissionField code;106	/// TokenPermission value.107	bool value;108}109110/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.111enum TokenPermissionField {112	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]113	Mutable,114	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]115	TokenOwner,116	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]117	CollectionAdmin118}119120/// @title A contract that allows you to work with collections.121/// @dev the ERC-165 identifier for this interface is 0xb34d97e9122interface Collection is Dummy, ERC165 {123	// /// Set collection property.124	// ///125	// /// @param key Property key.126	// /// @param value Propery value.127	// /// @dev EVM selector for this function is: 0x2f073f66,128	// ///  or in textual repr: setCollectionProperty(string,bytes)129	// function setCollectionProperty(string memory key, bytes memory value) external;130131	/// Set collection properties.132	///133	/// @param properties Vector of properties key/value pair.134	/// @dev EVM selector for this function is: 0x50b26b2a,135	///  or in textual repr: setCollectionProperties((string,bytes)[])136	function setCollectionProperties(Property[] memory properties) external;137138	// /// Delete collection property.139	// ///140	// /// @param key Property key.141	// /// @dev EVM selector for this function is: 0x7b7debce,142	// ///  or in textual repr: deleteCollectionProperty(string)143	// function deleteCollectionProperty(string memory key) external;144145	/// Delete collection properties.146	///147	/// @param keys Properties keys.148	/// @dev EVM selector for this function is: 0xee206ee3,149	///  or in textual repr: deleteCollectionProperties(string[])150	function deleteCollectionProperties(string[] memory keys) external;151152	/// Get collection property.153	///154	/// @dev Throws error if key not found.155	///156	/// @param key Property key.157	/// @return bytes The property corresponding to the key.158	/// @dev EVM selector for this function is: 0xcf24fd6d,159	///  or in textual repr: collectionProperty(string)160	function collectionProperty(string memory key) external view returns (bytes memory);161162	/// Get collection properties.163	///164	/// @param keys Properties keys. Empty keys for all propertyes.165	/// @return Vector of properties key/value pairs.166	/// @dev EVM selector for this function is: 0x285fb8e6,167	///  or in textual repr: collectionProperties(string[])168	function collectionProperties(string[] memory keys) external view returns (Property[] memory);169170	// /// Set the sponsor of the collection.171	// ///172	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.173	// ///174	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.175	// /// @dev EVM selector for this function is: 0x7623402e,176	// ///  or in textual repr: setCollectionSponsor(address)177	// function setCollectionSponsor(address sponsor) external;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 Cross account address of the sponsor from whose account funds will be debited for operations with the contract.184	/// @dev EVM selector for this function is: 0x84a1d5a8,185	///  or in textual repr: setCollectionSponsorCross((address,uint256))186	function setCollectionSponsorCross(CrossAddress memory sponsor) external;187188	/// Whether there is a pending sponsor.189	/// @dev EVM selector for this function is: 0x058ac185,190	///  or in textual repr: hasCollectionPendingSponsor()191	function hasCollectionPendingSponsor() external view returns (bool);192193	/// Collection sponsorship confirmation.194	///195	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.196	/// @dev EVM selector for this function is: 0x3c50e97a,197	///  or in textual repr: confirmCollectionSponsorship()198	function confirmCollectionSponsorship() external;199200	/// Remove collection sponsor.201	/// @dev EVM selector for this function is: 0x6e0326a3,202	///  or in textual repr: removeCollectionSponsor()203	function removeCollectionSponsor() external;204205	/// Get current sponsor.206	///207	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.208	/// @dev EVM selector for this function is: 0x6ec0a9f1,209	///  or in textual repr: collectionSponsor()210	function collectionSponsor() external view returns (CrossAddress memory);211212	/// Get current collection limits.213	///214	/// @return Array of collection limits215	/// @dev EVM selector for this function is: 0xf63bc572,216	///  or in textual repr: collectionLimits()217	function collectionLimits() external view returns (CollectionLimit[] memory);218219	/// Set limits for the collection.220	/// @dev Throws error if limit not found.221	/// @param limit Some limit.222	/// @dev EVM selector for this function is: 0x2316ee74,223	///  or in textual repr: setCollectionLimit((uint8,(bool,uint256)))224	function setCollectionLimit(CollectionLimit memory limit) external;225226	/// Get contract address.227	/// @dev EVM selector for this function is: 0xf6b4dfb4,228	///  or in textual repr: contractAddress()229	function contractAddress() external view returns (address);230231	/// Add collection admin.232	/// @param newAdmin Cross account administrator address.233	/// @dev EVM selector for this function is: 0x859aa7d6,234	///  or in textual repr: addCollectionAdminCross((address,uint256))235	function addCollectionAdminCross(CrossAddress memory newAdmin) external;236237	/// Remove collection admin.238	/// @param admin Cross account administrator address.239	/// @dev EVM selector for this function is: 0x6c0cd173,240	///  or in textual repr: removeCollectionAdminCross((address,uint256))241	function removeCollectionAdminCross(CrossAddress memory admin) external;242243	// /// Add collection admin.244	// /// @param newAdmin Address of the added administrator.245	// /// @dev EVM selector for this function is: 0x92e462c7,246	// ///  or in textual repr: addCollectionAdmin(address)247	// function addCollectionAdmin(address newAdmin) external;248249	// /// Remove collection admin.250	// ///251	// /// @param admin Address of the removed administrator.252	// /// @dev EVM selector for this function is: 0xfafd7b42,253	// ///  or in textual repr: removeCollectionAdmin(address)254	// function removeCollectionAdmin(address admin) external;255256	/// @dev EVM selector for this function is: 0x0b9f3890,257	///  or in textual repr: setCollectionNesting((bool,bool,address[]))258	function setCollectionNesting(CollectionNestingAndPermission memory collectionNestingAndPermissions) external;259260	// /// Toggle accessibility of collection nesting.261	// ///262	// /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'263	// /// @dev EVM selector for this function is: 0x112d4586,264	// ///  or in textual repr: setCollectionNesting(bool)265	// function setCollectionNesting(bool enable) external;266267	// /// Toggle accessibility of collection nesting.268	// ///269	// /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'270	// /// @param collections Addresses of collections that will be available for nesting.271	// /// @dev EVM selector for this function is: 0x64872396,272	// ///  or in textual repr: setCollectionNesting(bool,address[])273	// function setCollectionNesting(bool enable, address[] memory collections) external;274275	/// @dev EVM selector for this function is: 0x92c660a8,276	///  or in textual repr: collectionNesting()277	function collectionNesting() external view returns (CollectionNestingAndPermission memory);278279	// /// Returns nesting for a collection280	// /// @dev EVM selector for this function is: 0x22d25bfe,281	// ///  or in textual repr: collectionNestingRestrictedCollectionIds()282	// function collectionNestingRestrictedCollectionIds() external view returns (CollectionNesting memory);283284	// /// Returns permissions for a collection285	// /// @dev EVM selector for this function is: 0x5b2eaf4b,286	// ///  or in textual repr: collectionNestingPermissions()287	// function collectionNestingPermissions() external view returns (CollectionNestingPermission[] memory);288289	/// Set the collection access method.290	/// @param mode Access mode291	/// @dev EVM selector for this function is: 0x41835d4c,292	///  or in textual repr: setCollectionAccess(uint8)293	function setCollectionAccess(AccessMode mode) external;294295	/// Checks that user allowed to operate with collection.296	///297	/// @param user User address to check.298	/// @dev EVM selector for this function is: 0x91b6df49,299	///  or in textual repr: allowlistedCross((address,uint256))300	function allowlistedCross(CrossAddress memory user) external view returns (bool);301302	// /// Add the user to the allowed list.303	// ///304	// /// @param user Address of a trusted user.305	// /// @dev EVM selector for this function is: 0x67844fe6,306	// ///  or in textual repr: addToCollectionAllowList(address)307	// function addToCollectionAllowList(address user) external;308309	/// Add user to allowed list.310	///311	/// @param user User cross account address.312	/// @dev EVM selector for this function is: 0xa0184a3a,313	///  or in textual repr: addToCollectionAllowListCross((address,uint256))314	function addToCollectionAllowListCross(CrossAddress memory user) external;315316	// /// Remove the user from the allowed list.317	// ///318	// /// @param user Address of a removed user.319	// /// @dev EVM selector for this function is: 0x85c51acb,320	// ///  or in textual repr: removeFromCollectionAllowList(address)321	// function removeFromCollectionAllowList(address user) external;322323	/// Remove user from allowed list.324	///325	/// @param user User cross account address.326	/// @dev EVM selector for this function is: 0x09ba452a,327	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))328	function removeFromCollectionAllowListCross(CrossAddress memory user) external;329330	/// Switch permission for minting.331	///332	/// @param mode Enable if "true".333	/// @dev EVM selector for this function is: 0x00018e84,334	///  or in textual repr: setCollectionMintMode(bool)335	function setCollectionMintMode(bool mode) external;336337	// /// Check that account is the owner or admin of the collection338	// ///339	// /// @param user account to verify340	// /// @return "true" if account is the owner or admin341	// /// @dev EVM selector for this function is: 0x9811b0c7,342	// ///  or in textual repr: isOwnerOrAdmin(address)343	// function isOwnerOrAdmin(address user) external view returns (bool);344345	/// Check that account is the owner or admin of the collection346	///347	/// @param user User cross account to verify348	/// @return "true" if account is the owner or admin349	/// @dev EVM selector for this function is: 0x3e75a905,350	///  or in textual repr: isOwnerOrAdminCross((address,uint256))351	function isOwnerOrAdminCross(CrossAddress memory user) external view returns (bool);352353	/// Returns collection type354	///355	/// @return `Fungible` or `NFT` or `ReFungible`356	/// @dev EVM selector for this function is: 0xd34b55b8,357	///  or in textual repr: uniqueCollectionType()358	function uniqueCollectionType() external view returns (string memory);359360	/// Get collection owner.361	///362	/// @return Tuble with sponsor address and his substrate mirror.363	/// If address is canonical then substrate mirror is zero and vice versa.364	/// @dev EVM selector for this function is: 0xdf727d3b,365	///  or in textual repr: collectionOwner()366	function collectionOwner() external view returns (CrossAddress memory);367368	// /// Changes collection owner to another account369	// ///370	// /// @dev Owner can be changed only by current owner371	// /// @param newOwner new owner account372	// /// @dev EVM selector for this function is: 0x4f53e226,373	// ///  or in textual repr: changeCollectionOwner(address)374	// function changeCollectionOwner(address newOwner) external;375376	/// Get collection administrators377	///378	/// @return Vector of tuples with admins address and his substrate mirror.379	/// If address is canonical then substrate mirror is zero and vice versa.380	/// @dev EVM selector for this function is: 0x5813216b,381	///  or in textual repr: collectionAdmins()382	function collectionAdmins() external view returns (CrossAddress[] memory);383384	/// Changes collection owner to another account385	///386	/// @dev Owner can be changed only by current owner387	/// @param newOwner new owner cross account388	/// @dev EVM selector for this function is: 0x6496c497,389	///  or in textual repr: changeCollectionOwnerCross((address,uint256))390	function changeCollectionOwnerCross(CrossAddress memory newOwner) external;391}392393/// Cross account struct394struct CrossAddress {395	address eth;396	uint256 sub;397}398399/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).400enum AccessMode {401	/// Access grant for owner and admins. Used as default.402	Normal,403	/// Like a [`Normal`](AccessMode::Normal) but also users in allow list.404	AllowList405}406407/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.408struct CollectionNestingPermission {409	CollectionPermissionField field;410	bool value;411}412413/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.414enum CollectionPermissionField {415	/// Owner of token can nest tokens under it.416	TokenOwner,417	/// Admin of token collection can nest tokens under token.418	CollectionAdmin419}420421/// Nested collections.422struct CollectionNesting {423	bool token_owner;424	uint256[] ids;425}426427/// Nested collections and permissions428struct CollectionNestingAndPermission {429	/// Owner of token can nest tokens under it.430	bool token_owner;431	/// Admin of token collection can nest tokens under token.432	bool collection_admin;433	/// If set - only tokens from specified collections can be nested.434	address[] restricted;435}436437/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.438struct CollectionLimit {439	CollectionLimitField field;440	OptionUint256 value;441}442443/// Optional value444struct OptionUint256 {445	/// Shows the status of accessibility of value446	bool status;447	/// Actual value if `status` is true448	uint256 value;449}450451/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.452enum CollectionLimitField {453	/// How many tokens can a user have on one account.454	AccountTokenOwnership,455	/// How many bytes of data are available for sponsorship.456	SponsoredDataSize,457	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]458	SponsoredDataRateLimit,459	/// How many tokens can be mined into this collection.460	TokenLimit,461	/// Timeouts for transfer sponsoring.462	SponsorTransferTimeout,463	/// Timeout for sponsoring an approval in passed blocks.464	SponsorApproveTimeout,465	/// Whether the collection owner of the collection can send tokens (which belong to other users).466	OwnerCanTransfer,467	/// Can the collection owner burn other people's tokens.468	OwnerCanDestroy,469	/// Is it possible to send tokens from this collection between users.470	TransferEnabled471}472473/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension474/// @dev See https://eips.ethereum.org/EIPS/eip-721475/// @dev the ERC-165 identifier for this interface is 0x5b5e139f476interface ERC721Metadata is Dummy, ERC165 {477	// /// @notice A descriptive name for a collection of NFTs in this contract478	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`479	// /// @dev EVM selector for this function is: 0x06fdde03,480	// ///  or in textual repr: name()481	// function name() external view returns (string memory);482483	// /// @notice An abbreviated name for NFTs in this contract484	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`485	// /// @dev EVM selector for this function is: 0x95d89b41,486	// ///  or in textual repr: symbol()487	// function symbol() external view returns (string memory);488489	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.490	///491	/// @dev If the token has a `url` property and it is not empty, it is returned.492	///  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`.493	///  If the collection property `baseURI` is empty or absent, return "" (empty string)494	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix495	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).496	///497	/// @return token's const_metadata498	/// @dev EVM selector for this function is: 0xc87b56dd,499	///  or in textual repr: tokenURI(uint256)500	function tokenURI(uint256 tokenId) external view returns (string memory);501}502503/// @title ERC721 Token that can be irreversibly burned (destroyed).504/// @dev the ERC-165 identifier for this interface is 0x42966c68505interface ERC721Burnable is Dummy, ERC165 {506	/// @notice Burns a specific ERC721 token.507	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized508	///  operator of the current owner.509	/// @param tokenId The RFT to approve510	/// @dev EVM selector for this function is: 0x42966c68,511	///  or in textual repr: burn(uint256)512	function burn(uint256 tokenId) external;513}514515/// @title ERC721 minting logic.516/// @dev the ERC-165 identifier for this interface is 0x3fd94ea6517interface ERC721UniqueMintable is Dummy, ERC165 {518	/// @notice Function to mint a token.519	/// @param to The new owner520	/// @return uint256 The id of the newly minted token521	/// @dev EVM selector for this function is: 0x6a627842,522	///  or in textual repr: mint(address)523	function mint(address to) external returns (uint256);524525	// /// @notice Function to mint a token.526	// /// @dev `tokenId` should be obtained with `nextTokenId` method,527	// ///  unlike standard, you can't specify it manually528	// /// @param to The new owner529	// /// @param tokenId ID of the minted RFT530	// /// @dev EVM selector for this function is: 0x40c10f19,531	// ///  or in textual repr: mint(address,uint256)532	// function mint(address to, uint256 tokenId) external returns (bool);533534	/// @notice Function to mint token with the given tokenUri.535	/// @param to The new owner536	/// @param tokenUri Token URI that would be stored in the NFT properties537	/// @return uint256 The id of the newly minted token538	/// @dev EVM selector for this function is: 0x45c17782,539	///  or in textual repr: mintWithTokenURI(address,string)540	function mintWithTokenURI(address to, string memory tokenUri) external returns (uint256);541	// /// @notice Function to mint token with the given tokenUri.542	// /// @dev `tokenId` should be obtained with `nextTokenId` method,543	// ///  unlike standard, you can't specify it manually544	// /// @param to The new owner545	// /// @param tokenId ID of the minted RFT546	// /// @param tokenUri Token URI that would be stored in the RFT properties547	// /// @dev EVM selector for this function is: 0x50bb4e7f,548	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)549	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) external returns (bool);550551}552553/// @title Unique extensions for ERC721.554/// @dev the ERC-165 identifier for this interface is 0x3e828d60555interface ERC721UniqueExtensions is Dummy, ERC165 {556	/// @notice A descriptive name for a collection of NFTs in this contract557	/// @dev EVM selector for this function is: 0x06fdde03,558	///  or in textual repr: name()559	function name() external view returns (string memory);560561	/// @notice An abbreviated name for NFTs in this contract562	/// @dev EVM selector for this function is: 0x95d89b41,563	///  or in textual repr: symbol()564	function symbol() external view returns (string memory);565566	/// @notice A description for the collection.567	/// @dev EVM selector for this function is: 0x7284e416,568	///  or in textual repr: description()569	function description() external view returns (string memory);570571	// /// Returns the owner (in cross format) of the token.572	// ///573	// /// @param tokenId Id for the token.574	// /// @dev EVM selector for this function is: 0x2b29dace,575	// ///  or in textual repr: crossOwnerOf(uint256)576	// function crossOwnerOf(uint256 tokenId) external view returns (CrossAddress memory);577578	/// Returns the owner (in cross format) of the token.579	///580	/// @param tokenId Id for the token.581	/// @dev EVM selector for this function is: 0xcaa3a4d0,582	///  or in textual repr: ownerOfCross(uint256)583	function ownerOfCross(uint256 tokenId) external view returns (CrossAddress memory);584585	/// @notice Count all RFTs assigned to an owner586	/// @param owner An cross address for whom to query the balance587	/// @return The number of RFTs owned by `owner`, possibly zero588	/// @dev EVM selector for this function is: 0xec069398,589	///  or in textual repr: balanceOfCross((address,uint256))590	function balanceOfCross(CrossAddress memory owner) external view returns (uint256);591592	/// Returns the token properties.593	///594	/// @param tokenId Id for the token.595	/// @param keys Properties keys. Empty keys for all propertyes.596	/// @return Vector of properties key/value pairs.597	/// @dev EVM selector for this function is: 0xe07ede7e,598	///  or in textual repr: properties(uint256,string[])599	function properties(uint256 tokenId, string[] memory keys) external view returns (Property[] memory);600601	/// @notice Transfer ownership of an RFT602	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`603	///  is the zero address. Throws if `tokenId` is not a valid RFT.604	///  Throws if RFT pieces have multiple owners.605	/// @param to The new owner606	/// @param tokenId The RFT to transfer607	/// @dev EVM selector for this function is: 0xa9059cbb,608	///  or in textual repr: transfer(address,uint256)609	function transfer(address to, uint256 tokenId) external;610611	/// @notice Transfer ownership of an RFT612	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`613	///  is the zero address. Throws if `tokenId` is not a valid RFT.614	///  Throws if RFT pieces have multiple owners.615	/// @param to The new owner616	/// @param tokenId The RFT to transfer617	/// @dev EVM selector for this function is: 0x2ada85ff,618	///  or in textual repr: transferCross((address,uint256),uint256)619	function transferCross(CrossAddress memory to, uint256 tokenId) external;620621	/// @notice Transfer ownership of an RFT622	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`623	///  is the zero address. Throws if `tokenId` is not a valid RFT.624	///  Throws if RFT pieces have multiple owners.625	/// @param to The new owner626	/// @param tokenId The RFT to transfer627	/// @dev EVM selector for this function is: 0xd5cf430b,628	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)629	function transferFromCross(630		CrossAddress memory from,631		CrossAddress memory to,632		uint256 tokenId633	) external;634635	// /// @notice Burns a specific ERC721 token.636	// /// @dev Throws unless `msg.sender` is the current owner or an authorized637	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws638	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.639	// ///  Throws if RFT pieces have multiple owners.640	// /// @param from The current owner of the RFT641	// /// @param tokenId The RFT to transfer642	// /// @dev EVM selector for this function is: 0x79cc6790,643	// ///  or in textual repr: burnFrom(address,uint256)644	// function burnFrom(address from, uint256 tokenId) external;645646	/// @notice Burns a specific ERC721 token.647	/// @dev Throws unless `msg.sender` is the current owner or an authorized648	///  operator for this RFT. Throws if `from` is not the current owner. Throws649	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.650	///  Throws if RFT pieces have multiple owners.651	/// @param from The current owner of the RFT652	/// @param tokenId The RFT to transfer653	/// @dev EVM selector for this function is: 0xbb2f5a58,654	///  or in textual repr: burnFromCross((address,uint256),uint256)655	function burnFromCross(CrossAddress memory from, uint256 tokenId) external;656657	/// @notice Returns next free RFT ID.658	/// @dev EVM selector for this function is: 0x75794a3c,659	///  or in textual repr: nextTokenId()660	function nextTokenId() external view returns (uint256);661662	// /// @notice Function to mint multiple tokens.663	// /// @dev `tokenIds` should be an array of consecutive numbers and first number664	// ///  should be obtained with `nextTokenId` method665	// /// @param to The new owner666	// /// @param tokenIds IDs of the minted RFTs667	// /// @dev EVM selector for this function is: 0x44a9945e,668	// ///  or in textual repr: mintBulk(address,uint256[])669	// function mintBulk(address to, uint256[] memory tokenIds) external returns (bool);670671	/// @notice Function to mint a token.672	/// @param tokenProperties Properties of minted token673	/// @dev EVM selector for this function is: 0xab427b0c,674	///  or in textual repr: mintBulkCross(((address,uint256),(string,bytes)[])[])675	function mintBulkCross(MintTokenData[] memory tokenProperties) external returns (bool);676677	// /// @notice Function to mint multiple tokens with the given tokenUris.678	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive679	// ///  numbers and first number should be obtained with `nextTokenId` method680	// /// @param to The new owner681	// /// @param tokens array of pairs of token ID and token URI for minted tokens682	// /// @dev EVM selector for this function is: 0x36543006,683	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])684	// function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) external returns (bool);685686	/// @notice Function to mint a token.687	/// @param to The new owner crossAccountId688	/// @param properties Properties of minted token689	/// @return uint256 The id of the newly minted token690	/// @dev EVM selector for this function is: 0xb904db03,691	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])692	function mintCross(CrossAddress memory to, Property[] memory properties) external returns (uint256);693694	/// Returns EVM address for refungible token695	///696	/// @param token ID of the token697	/// @dev EVM selector for this function is: 0xab76fac6,698	///  or in textual repr: tokenContractAddress(uint256)699	function tokenContractAddress(uint256 token) external view returns (address);700701	/// @notice Returns collection helper contract address702	/// @dev EVM selector for this function is: 0x1896cce6,703	///  or in textual repr: collectionHelperAddress()704	function collectionHelperAddress() external view returns (address);705}706707/// Data for creation token with uri.708struct TokenUri {709	/// Id of new token.710	uint256 id;711	/// Uri of new token.712	string uri;713}714715struct MintTokenData {716	CrossAddress owner;717	Property[] properties;718}719720/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension721/// @dev See https://eips.ethereum.org/EIPS/eip-721722/// @dev the ERC-165 identifier for this interface is 0x780e9d63723interface ERC721Enumerable is Dummy, ERC165 {724	/// @notice Enumerate valid RFTs725	/// @param index A counter less than `totalSupply()`726	/// @return The token identifier for the `index`th NFT,727	///  (sort order not specified)728	/// @dev EVM selector for this function is: 0x4f6ccce7,729	///  or in textual repr: tokenByIndex(uint256)730	function tokenByIndex(uint256 index) external view returns (uint256);731732	/// Not implemented733	/// @dev EVM selector for this function is: 0x2f745c59,734	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)735	function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);736737	/// @notice Count RFTs tracked by this contract738	/// @return A count of valid RFTs tracked by this contract, where each one of739	///  them has an assigned and queryable owner not equal to the zero address740	/// @dev EVM selector for this function is: 0x18160ddd,741	///  or in textual repr: totalSupply()742	function totalSupply() external view returns (uint256);743}744745/// @dev inlined interface746interface ERC721Events {747	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);748	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);749	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);750}751752/// @title ERC-721 Non-Fungible Token Standard753/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md754/// @dev the ERC-165 identifier for this interface is 0x80ac58cd755interface ERC721 is Dummy, ERC165, ERC721Events {756	/// @notice Count all RFTs assigned to an owner757	/// @dev RFTs assigned to the zero address are considered invalid, and this758	///  function throws for queries about the zero address.759	/// @param owner An address for whom to query the balance760	/// @return The number of RFTs owned by `owner`, possibly zero761	/// @dev EVM selector for this function is: 0x70a08231,762	///  or in textual repr: balanceOf(address)763	function balanceOf(address owner) external view returns (uint256);764765	/// @notice Find the owner of an RFT766	/// @dev RFTs assigned to zero address are considered invalid, and queries767	///  about them do throw.768	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for769	///  the tokens that are partially owned.770	/// @param tokenId The identifier for an RFT771	/// @return The address of the owner of the RFT772	/// @dev EVM selector for this function is: 0x6352211e,773	///  or in textual repr: ownerOf(uint256)774	function ownerOf(uint256 tokenId) external view returns (address);775776	/// @dev Not implemented777	/// @dev EVM selector for this function is: 0xb88d4fde,778	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)779	function safeTransferFrom(780		address from,781		address to,782		uint256 tokenId,783		bytes memory data784	) external;785786	/// @dev Not implemented787	/// @dev EVM selector for this function is: 0x42842e0e,788	///  or in textual repr: safeTransferFrom(address,address,uint256)789	function safeTransferFrom(790		address from,791		address to,792		uint256 tokenId793	) external;794795	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE796	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE797	///  THEY MAY BE PERMANENTLY LOST798	/// @dev Throws unless `msg.sender` is the current owner or an authorized799	///  operator for this RFT. Throws if `from` is not the current owner. Throws800	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.801	///  Throws if RFT pieces have multiple owners.802	/// @param from The current owner of the NFT803	/// @param to The new owner804	/// @param tokenId The NFT to transfer805	/// @dev EVM selector for this function is: 0x23b872dd,806	///  or in textual repr: transferFrom(address,address,uint256)807	function transferFrom(808		address from,809		address to,810		uint256 tokenId811	) external;812813	/// @dev Not implemented814	/// @dev EVM selector for this function is: 0x095ea7b3,815	///  or in textual repr: approve(address,uint256)816	function approve(address approved, uint256 tokenId) external;817818	/// @notice Sets or unsets the approval of a given operator.819	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.820	/// @param operator Operator821	/// @param approved Should operator status be granted or revoked?822	/// @dev EVM selector for this function is: 0xa22cb465,823	///  or in textual repr: setApprovalForAll(address,bool)824	function setApprovalForAll(address operator, bool approved) external;825826	/// @dev Not implemented827	/// @dev EVM selector for this function is: 0x081812fc,828	///  or in textual repr: getApproved(uint256)829	function getApproved(uint256 tokenId) external view returns (address);830831	/// @notice Tells whether the given `owner` approves the `operator`.832	/// @dev EVM selector for this function is: 0xe985e9c5,833	///  or in textual repr: isApprovedForAll(address,address)834	function isApprovedForAll(address owner, address operator) external view returns (bool);835}836837interface UniqueRefungible is838	Dummy,839	ERC165,840	ERC721,841	ERC721Enumerable,842	ERC721UniqueExtensions,843	ERC721UniqueMintable,844	ERC721Burnable,845	ERC721Metadata,846	Collection,847	TokenProperties848{}