git.delta.rocks / unique-network / refs/commits / e624910c94ca

1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8	uint8 dummy;9	string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13	function supportsInterface(bytes4 interfaceID) external view returns (bool) {14		require(false, stub_error);15		interfaceID;16		return true;17	}18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0xde0695c222contract TokenProperties is Dummy, ERC165 {23	// /// @notice Set permissions for token property.24	// /// @dev Throws error if `msg.sender` is not admin or owner of the collection.25	// /// @param key Property key.26	// /// @param isMutable Permission to mutate property.27	// /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28	// /// @param tokenOwner Permission to mutate property by token owner if property is mutable.29	// /// @dev EVM selector for this function is: 0x222d97fa,30	// ///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31	// function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {32	// 	require(false, stub_error);33	// 	key;34	// 	isMutable;35	// 	collectionAdmin;36	// 	tokenOwner;37	// 	dummy = 0;38	// }3940	/// @notice Set permissions for token property.41	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.42	/// @param permissions Permissions for keys.43	/// @dev EVM selector for this function is: 0xbd92983a,44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])45<<<<<<< HEAD46	function setTokenPropertyPermissions(Tuple58[] memory permissions) public {47=======48	function setTokenPropertyPermissions(Tuple55[] memory permissions) public {49>>>>>>> 9e929f90... chore: generate stubs & types50		require(false, stub_error);51		permissions;52		dummy = 0;53	}5455	/// @notice Get permissions for token properties.56	/// @dev EVM selector for this function is: 0xf23d7790,57	///  or in textual repr: tokenPropertyPermissions()58<<<<<<< HEAD59	function tokenPropertyPermissions() public view returns (Tuple58[] memory) {60		require(false, stub_error);61		dummy;62		return new Tuple58[](0);63=======64	function tokenPropertyPermissions() public view returns (Tuple55[] memory) {65		require(false, stub_error);66		dummy;67		return new Tuple55[](0);68>>>>>>> 9e929f90... chore: generate stubs & types69	}7071	// /// @notice Set token property value.72	// /// @dev Throws error if `msg.sender` has no permission to edit the property.73	// /// @param tokenId ID of the token.74	// /// @param key Property key.75	// /// @param value Property value.76	// /// @dev EVM selector for this function is: 0x1752d67b,77	// ///  or in textual repr: setProperty(uint256,string,bytes)78	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {79	// 	require(false, stub_error);80	// 	tokenId;81	// 	key;82	// 	value;83	// 	dummy = 0;84	// }8586	/// @notice Set token properties value.87	/// @dev Throws error if `msg.sender` has no permission to edit the property.88	/// @param tokenId ID of the token.89	/// @param properties settable properties90	/// @dev EVM selector for this function is: 0x14ed3a6e,91	///  or in textual repr: setProperties(uint256,(string,bytes)[])92	function setProperties(uint256 tokenId, Property[] memory properties) public {93		require(false, stub_error);94		tokenId;95		properties;96		dummy = 0;97	}9899	// /// @notice Delete token property value.100	// /// @dev Throws error if `msg.sender` has no permission to edit the property.101	// /// @param tokenId ID of the token.102	// /// @param key Property key.103	// /// @dev EVM selector for this function is: 0x066111d1,104	// ///  or in textual repr: deleteProperty(uint256,string)105	// function deleteProperty(uint256 tokenId, string memory key) public {106	// 	require(false, stub_error);107	// 	tokenId;108	// 	key;109	// 	dummy = 0;110	// }111112	/// @notice Delete token properties value.113	/// @dev Throws error if `msg.sender` has no permission to edit the property.114	/// @param tokenId ID of the token.115	/// @param keys Properties key.116	/// @dev EVM selector for this function is: 0xc472d371,117	///  or in textual repr: deleteProperties(uint256,string[])118	function deleteProperties(uint256 tokenId, string[] memory keys) public {119		require(false, stub_error);120		tokenId;121		keys;122		dummy = 0;123	}124125	/// @notice Get token property value.126	/// @dev Throws error if key not found127	/// @param tokenId ID of the token.128	/// @param key Property key.129	/// @return Property value bytes130	/// @dev EVM selector for this function is: 0x7228c327,131	///  or in textual repr: property(uint256,string)132	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {133		require(false, stub_error);134		tokenId;135		key;136		dummy;137		return hex"";138	}139}140141/// @dev Property struct142struct Property {143	string key;144	bytes value;145}146147/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.148enum EthTokenPermissions {149	/// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]150	Mutable,151	/// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]152	TokenOwner,153	/// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]154	CollectionAdmin155}156157/// @dev anonymous struct158<<<<<<< HEAD159struct Tuple58 {160	string field_0;161	Tuple56[] field_1;162}163164/// @dev anonymous struct165struct Tuple56 {166=======167struct Tuple55 {168	string field_0;169	Tuple53[] field_1;170}171172/// @dev anonymous struct173struct Tuple53 {174>>>>>>> 9e929f90... chore: generate stubs & types175	EthTokenPermissions field_0;176	bool field_1;177}178179/// @title A contract that allows you to work with collections.180/// @dev the ERC-165 identifier for this interface is 0x81172a75181contract Collection is Dummy, ERC165 {182	// /// Set collection property.183	// ///184	// /// @param key Property key.185	// /// @param value Propery value.186	// /// @dev EVM selector for this function is: 0x2f073f66,187	// ///  or in textual repr: setCollectionProperty(string,bytes)188	// function setCollectionProperty(string memory key, bytes memory value) public {189	// 	require(false, stub_error);190	// 	key;191	// 	value;192	// 	dummy = 0;193	// }194195	/// Set collection properties.196	///197	/// @param properties Vector of properties key/value pair.198	/// @dev EVM selector for this function is: 0x50b26b2a,199	///  or in textual repr: setCollectionProperties((string,bytes)[])200	function setCollectionProperties(Property[] memory properties) public {201		require(false, stub_error);202		properties;203		dummy = 0;204	}205206	// /// Delete collection property.207	// ///208	// /// @param key Property key.209	// /// @dev EVM selector for this function is: 0x7b7debce,210	// ///  or in textual repr: deleteCollectionProperty(string)211	// function deleteCollectionProperty(string memory key) public {212	// 	require(false, stub_error);213	// 	key;214	// 	dummy = 0;215	// }216217	/// Delete collection properties.218	///219	/// @param keys Properties keys.220	/// @dev EVM selector for this function is: 0xee206ee3,221	///  or in textual repr: deleteCollectionProperties(string[])222	function deleteCollectionProperties(string[] memory keys) public {223		require(false, stub_error);224		keys;225		dummy = 0;226	}227228	/// Get collection property.229	///230	/// @dev Throws error if key not found.231	///232	/// @param key Property key.233	/// @return bytes The property corresponding to the key.234	/// @dev EVM selector for this function is: 0xcf24fd6d,235	///  or in textual repr: collectionProperty(string)236	function collectionProperty(string memory key) public view returns (bytes memory) {237		require(false, stub_error);238		key;239		dummy;240		return hex"";241	}242243	/// Get collection properties.244	///245	/// @param keys Properties keys. Empty keys for all propertyes.246	/// @return Vector of properties key/value pairs.247	/// @dev EVM selector for this function is: 0x285fb8e6,248	///  or in textual repr: collectionProperties(string[])249	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {250		require(false, stub_error);251		keys;252		dummy;253		return new Property[](0);254	}255256	// /// Set the sponsor of the collection.257	// ///258	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.259	// ///260	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.261	// /// @dev EVM selector for this function is: 0x7623402e,262	// ///  or in textual repr: setCollectionSponsor(address)263	// function setCollectionSponsor(address sponsor) public {264	// 	require(false, stub_error);265	// 	sponsor;266	// 	dummy = 0;267	// }268269	/// Set the sponsor of the collection.270	///271	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.272	///273	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.274	/// @dev EVM selector for this function is: 0x84a1d5a8,275	///  or in textual repr: setCollectionSponsorCross((address,uint256))276	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {277		require(false, stub_error);278		sponsor;279		dummy = 0;280	}281282	/// Whether there is a pending sponsor.283	/// @dev EVM selector for this function is: 0x058ac185,284	///  or in textual repr: hasCollectionPendingSponsor()285	function hasCollectionPendingSponsor() public view returns (bool) {286		require(false, stub_error);287		dummy;288		return false;289	}290291	/// Collection sponsorship confirmation.292	///293	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.294	/// @dev EVM selector for this function is: 0x3c50e97a,295	///  or in textual repr: confirmCollectionSponsorship()296	function confirmCollectionSponsorship() public {297		require(false, stub_error);298		dummy = 0;299	}300301	/// Remove collection sponsor.302	/// @dev EVM selector for this function is: 0x6e0326a3,303	///  or in textual repr: removeCollectionSponsor()304	function removeCollectionSponsor() public {305		require(false, stub_error);306		dummy = 0;307	}308309	/// Get current sponsor.310	///311	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.312	/// @dev EVM selector for this function is: 0x6ec0a9f1,313	///  or in textual repr: collectionSponsor()314	function collectionSponsor() public view returns (EthCrossAccount memory) {315		require(false, stub_error);316		dummy;317		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);318	}319320	/// Get current collection limits.321	///322	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:323	/// 	"accountTokenOwnershipLimit",324	/// 	"sponsoredDataSize",325	/// 	"sponsoredDataRateLimit",326	/// 	"tokenLimit",327	/// 	"sponsorTransferTimeout",328	/// 	"sponsorApproveTimeout"329	///  	"ownerCanTransfer",330	/// 	"ownerCanDestroy",331	/// 	"transfersEnabled"332	/// Return `false` if a limit not set.333	/// @dev EVM selector for this function is: 0xf63bc572,334	///  or in textual repr: collectionLimits()335	function collectionLimits() public view returns (Tuple32[] memory) {336		require(false, stub_error);337		dummy;338		return new Tuple32[](0);339	}340341	/// Set limits for the collection.342	/// @dev Throws error if limit not found.343	/// @param limit Name of the limit. Valid names:344	/// 	"accountTokenOwnershipLimit",345	/// 	"sponsoredDataSize",346	/// 	"sponsoredDataRateLimit",347	/// 	"tokenLimit",348	/// 	"sponsorTransferTimeout",349	/// 	"sponsorApproveTimeout"350	///  	"ownerCanTransfer",351	/// 	"ownerCanDestroy",352	/// 	"transfersEnabled"353	/// @param status enable\disable limit. Works only with `true`.354	/// @param value Value of the limit.355	/// @dev EVM selector for this function is: 0x88150bd0,356	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)357	function setCollectionLimit(358		CollectionLimits limit,359		bool status,360		uint256 value361	) public {362		require(false, stub_error);363		limit;364		status;365		value;366		dummy = 0;367	}368369	/// Get contract address.370	/// @dev EVM selector for this function is: 0xf6b4dfb4,371	///  or in textual repr: contractAddress()372	function contractAddress() public view returns (address) {373		require(false, stub_error);374		dummy;375		return 0x0000000000000000000000000000000000000000;376	}377378	/// Add collection admin.379	/// @param newAdmin Cross account administrator address.380	/// @dev EVM selector for this function is: 0x859aa7d6,381	///  or in textual repr: addCollectionAdminCross((address,uint256))382	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {383		require(false, stub_error);384		newAdmin;385		dummy = 0;386	}387388	/// Remove collection admin.389	/// @param admin Cross account administrator address.390	/// @dev EVM selector for this function is: 0x6c0cd173,391	///  or in textual repr: removeCollectionAdminCross((address,uint256))392	function removeCollectionAdminCross(EthCrossAccount memory admin) public {393		require(false, stub_error);394		admin;395		dummy = 0;396	}397398	// /// Add collection admin.399	// /// @param newAdmin Address of the added administrator.400	// /// @dev EVM selector for this function is: 0x92e462c7,401	// ///  or in textual repr: addCollectionAdmin(address)402	// function addCollectionAdmin(address newAdmin) public {403	// 	require(false, stub_error);404	// 	newAdmin;405	// 	dummy = 0;406	// }407408	// /// Remove collection admin.409	// ///410	// /// @param admin Address of the removed administrator.411	// /// @dev EVM selector for this function is: 0xfafd7b42,412	// ///  or in textual repr: removeCollectionAdmin(address)413	// function removeCollectionAdmin(address admin) public {414	// 	require(false, stub_error);415	// 	admin;416	// 	dummy = 0;417	// }418419	/// Toggle accessibility of collection nesting.420	///421	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'422	/// @dev EVM selector for this function is: 0x112d4586,423	///  or in textual repr: setCollectionNesting(bool)424	function setCollectionNesting(bool enable) public {425		require(false, stub_error);426		enable;427		dummy = 0;428	}429430	/// Toggle accessibility of collection nesting.431	///432	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'433	/// @param collections Addresses of collections that will be available for nesting.434	/// @dev EVM selector for this function is: 0x64872396,435	///  or in textual repr: setCollectionNesting(bool,address[])436	function setCollectionNesting(bool enable, address[] memory collections) public {437		require(false, stub_error);438		enable;439		collections;440		dummy = 0;441	}442443	/// Returns nesting for a collection444	/// @dev EVM selector for this function is: 0x22d25bfe,445	///  or in textual repr: collectionNestingRestrictedCollectionIds()446<<<<<<< HEAD447	function collectionNestingRestrictedCollectionIds() public view returns (Tuple38 memory) {448		require(false, stub_error);449		dummy;450		return Tuple38(false, new uint256[](0));451=======452	function collectionNestingRestrictedCollectionIds() public view returns (Tuple35 memory) {453		require(false, stub_error);454		dummy;455		return Tuple35(false, new uint256[](0));456>>>>>>> 09f69700... chore: generate stubs457	}458459	/// Returns permissions for a collection460	/// @dev EVM selector for this function is: 0x5b2eaf4b,461	///  or in textual repr: collectionNestingPermissions()462<<<<<<< HEAD463	function collectionNestingPermissions() public view returns (Tuple41[] memory) {464		require(false, stub_error);465		dummy;466		return new Tuple41[](0);467=======468	function collectionNestingPermissions() public view returns (Tuple38[] memory) {469		require(false, stub_error);470		dummy;471		return new Tuple38[](0);472>>>>>>> 09f69700... chore: generate stubs473	}474475	/// Set the collection access method.476	/// @param mode Access mode477	/// 	0 for Normal478	/// 	1 for AllowList479	/// @dev EVM selector for this function is: 0x41835d4c,480	///  or in textual repr: setCollectionAccess(uint8)481	function setCollectionAccess(uint8 mode) public {482		require(false, stub_error);483		mode;484		dummy = 0;485	}486487	/// Checks that user allowed to operate with collection.488	///489	/// @param user User address to check.490	/// @dev EVM selector for this function is: 0x91b6df49,491	///  or in textual repr: allowlistedCross((address,uint256))492	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {493		require(false, stub_error);494		user;495		dummy;496		return false;497	}498499	// /// Add the user to the allowed list.500	// ///501	// /// @param user Address of a trusted user.502	// /// @dev EVM selector for this function is: 0x67844fe6,503	// ///  or in textual repr: addToCollectionAllowList(address)504	// function addToCollectionAllowList(address user) public {505	// 	require(false, stub_error);506	// 	user;507	// 	dummy = 0;508	// }509510	/// Add user to allowed list.511	///512	/// @param user User cross account address.513	/// @dev EVM selector for this function is: 0xa0184a3a,514	///  or in textual repr: addToCollectionAllowListCross((address,uint256))515	function addToCollectionAllowListCross(EthCrossAccount memory user) public {516		require(false, stub_error);517		user;518		dummy = 0;519	}520521	// /// Remove the user from the allowed list.522	// ///523	// /// @param user Address of a removed user.524	// /// @dev EVM selector for this function is: 0x85c51acb,525	// ///  or in textual repr: removeFromCollectionAllowList(address)526	// function removeFromCollectionAllowList(address user) public {527	// 	require(false, stub_error);528	// 	user;529	// 	dummy = 0;530	// }531532	/// Remove user from allowed list.533	///534	/// @param user User cross account address.535	/// @dev EVM selector for this function is: 0x09ba452a,536	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))537	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {538		require(false, stub_error);539		user;540		dummy = 0;541	}542543	/// Switch permission for minting.544	///545	/// @param mode Enable if "true".546	/// @dev EVM selector for this function is: 0x00018e84,547	///  or in textual repr: setCollectionMintMode(bool)548	function setCollectionMintMode(bool mode) public {549		require(false, stub_error);550		mode;551		dummy = 0;552	}553554	// /// Check that account is the owner or admin of the collection555	// ///556	// /// @param user account to verify557	// /// @return "true" if account is the owner or admin558	// /// @dev EVM selector for this function is: 0x9811b0c7,559	// ///  or in textual repr: isOwnerOrAdmin(address)560	// function isOwnerOrAdmin(address user) public view returns (bool) {561	// 	require(false, stub_error);562	// 	user;563	// 	dummy;564	// 	return false;565	// }566567	/// Check that account is the owner or admin of the collection568	///569	/// @param user User cross account to verify570	/// @return "true" if account is the owner or admin571	/// @dev EVM selector for this function is: 0x3e75a905,572	///  or in textual repr: isOwnerOrAdminCross((address,uint256))573	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {574		require(false, stub_error);575		user;576		dummy;577		return false;578	}579580	/// Returns collection type581	///582	/// @return `Fungible` or `NFT` or `ReFungible`583	/// @dev EVM selector for this function is: 0xd34b55b8,584	///  or in textual repr: uniqueCollectionType()585	function uniqueCollectionType() public view returns (string memory) {586		require(false, stub_error);587		dummy;588		return "";589	}590591	/// Get collection owner.592	///593	/// @return Tuble with sponsor address and his substrate mirror.594	/// If address is canonical then substrate mirror is zero and vice versa.595	/// @dev EVM selector for this function is: 0xdf727d3b,596	///  or in textual repr: collectionOwner()597	function collectionOwner() public view returns (EthCrossAccount memory) {598		require(false, stub_error);599		dummy;600		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);601	}602603	// /// Changes collection owner to another account604	// ///605	// /// @dev Owner can be changed only by current owner606	// /// @param newOwner new owner account607	// /// @dev EVM selector for this function is: 0x4f53e226,608	// ///  or in textual repr: changeCollectionOwner(address)609	// function changeCollectionOwner(address newOwner) public {610	// 	require(false, stub_error);611	// 	newOwner;612	// 	dummy = 0;613	// }614615	/// Get collection administrators616	///617	/// @return Vector of tuples with admins address and his substrate mirror.618	/// If address is canonical then substrate mirror is zero and vice versa.619	/// @dev EVM selector for this function is: 0x5813216b,620	///  or in textual repr: collectionAdmins()621	function collectionAdmins() public view returns (EthCrossAccount[] memory) {622		require(false, stub_error);623		dummy;624		return new EthCrossAccount[](0);625	}626627	/// Changes collection owner to another account628	///629	/// @dev Owner can be changed only by current owner630	/// @param newOwner new owner cross account631	/// @dev EVM selector for this function is: 0x6496c497,632	///  or in textual repr: changeCollectionOwnerCross((address,uint256))633	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {634		require(false, stub_error);635		newOwner;636		dummy = 0;637	}638}639640/// @dev Cross account struct641struct EthCrossAccount {642	address eth;643	uint256 sub;644}645646enum CollectionPermissions {647	CollectionAdmin,648	TokenOwner649}650651/// @dev anonymous struct652<<<<<<< HEAD653struct Tuple41 {654=======655struct Tuple38 {656>>>>>>> 09f69700... chore: generate stubs657	CollectionPermissions field_0;658	bool field_1;659}660661/// @dev anonymous struct662<<<<<<< HEAD663struct Tuple38 {664=======665struct Tuple35 {666>>>>>>> 09f69700... chore: generate stubs667	bool field_0;668	uint256[] field_1;669}670671<<<<<<< HEAD672/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.673enum CollectionLimits {674	/// @dev How many tokens can a user have on one account.675	AccountTokenOwnership,676	/// @dev How many bytes of data are available for sponsorship.677	SponsoredDataSize,678	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]679	SponsoredDataRateLimit,680	/// @dev How many tokens can be mined into this collection.681	TokenLimit,682	/// @dev Timeouts for transfer sponsoring.683	SponsorTransferTimeout,684	/// @dev Timeout for sponsoring an approval in passed blocks.685	SponsorApproveTimeout,686	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).687	OwnerCanTransfer,688	/// @dev Can the collection owner burn other people's tokens.689	OwnerCanDestroy,690	/// @dev Is it possible to send tokens from this collection between users.691	TransferEnabled692}693694/// @dev anonymous struct695struct Tuple32 {696	CollectionLimits field_0;697	bool field_1;698	uint256 field_2;699}700701/// @dev anonymous struct702struct Tuple31 {703	address field_0;704	uint256 field_1;705}706707=======708>>>>>>> 09f69700... chore: generate stubs709/// @dev the ERC-165 identifier for this interface is 0x5b5e139f710contract ERC721Metadata is Dummy, ERC165 {711	// /// @notice A descriptive name for a collection of NFTs in this contract712	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`713	// /// @dev EVM selector for this function is: 0x06fdde03,714	// ///  or in textual repr: name()715	// function name() public view returns (string memory) {716	// 	require(false, stub_error);717	// 	dummy;718	// 	return "";719	// }720721	// /// @notice An abbreviated name for NFTs in this contract722	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`723	// /// @dev EVM selector for this function is: 0x95d89b41,724	// ///  or in textual repr: symbol()725	// function symbol() public view returns (string memory) {726	// 	require(false, stub_error);727	// 	dummy;728	// 	return "";729	// }730731	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.732	///733	/// @dev If the token has a `url` property and it is not empty, it is returned.734	///  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`.735	///  If the collection property `baseURI` is empty or absent, return "" (empty string)736	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix737	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).738	///739	/// @return token's const_metadata740	/// @dev EVM selector for this function is: 0xc87b56dd,741	///  or in textual repr: tokenURI(uint256)742	function tokenURI(uint256 tokenId) public view returns (string memory) {743		require(false, stub_error);744		tokenId;745		dummy;746		return "";747	}748}749750/// @title ERC721 Token that can be irreversibly burned (destroyed).751/// @dev the ERC-165 identifier for this interface is 0x42966c68752contract ERC721Burnable is Dummy, ERC165 {753	/// @notice Burns a specific ERC721 token.754	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized755	///  operator of the current owner.756	/// @param tokenId The RFT to approve757	/// @dev EVM selector for this function is: 0x42966c68,758	///  or in textual repr: burn(uint256)759	function burn(uint256 tokenId) public {760		require(false, stub_error);761		tokenId;762		dummy = 0;763	}764}765766/// @dev inlined interface767contract ERC721UniqueMintableEvents {768	event MintingFinished();769}770771/// @title ERC721 minting logic.772/// @dev the ERC-165 identifier for this interface is 0x476ff149773contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {774	/// @dev EVM selector for this function is: 0x05d2035b,775	///  or in textual repr: mintingFinished()776	function mintingFinished() public view returns (bool) {777		require(false, stub_error);778		dummy;779		return false;780	}781782	/// @notice Function to a mint token.783	/// @param to The new owner784	/// @return uint256 The id of the newly minted token785	/// @dev EVM selector for this function is: 0x6a627842,786	///  or in textual repr: mint(address)787	function mint(address to) public returns (uint256) {788		require(false, stub_error);789		to;790		dummy = 0;791		return 0;792	}793794	// /// @notice Function to a mint token.795	// /// @dev `tokenId` should be obtained with `nextTokenId` method,796	// ///  unlike standard, you can't specify it manually797	// /// @param to The new owner798	// /// @param tokenId ID of the minted RFT799	// /// @dev EVM selector for this function is: 0x40c10f19,800	// ///  or in textual repr: mint(address,uint256)801	// function mint(address to, uint256 tokenId) public returns (bool) {802	// 	require(false, stub_error);803	// 	to;804	// 	tokenId;805	// 	dummy = 0;806	// 	return false;807	// }808809	/// @notice Function to mint token with the given tokenUri.810	/// @param to The new owner811	/// @param tokenUri Token URI that would be stored in the NFT properties812	/// @return uint256 The id of the newly minted token813	/// @dev EVM selector for this function is: 0x45c17782,814	///  or in textual repr: mintWithTokenURI(address,string)815	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {816		require(false, stub_error);817		to;818		tokenUri;819		dummy = 0;820		return 0;821	}822823	// /// @notice Function to mint token with the given tokenUri.824	// /// @dev `tokenId` should be obtained with `nextTokenId` method,825	// ///  unlike standard, you can't specify it manually826	// /// @param to The new owner827	// /// @param tokenId ID of the minted RFT828	// /// @param tokenUri Token URI that would be stored in the RFT properties829	// /// @dev EVM selector for this function is: 0x50bb4e7f,830	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)831	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {832	// 	require(false, stub_error);833	// 	to;834	// 	tokenId;835	// 	tokenUri;836	// 	dummy = 0;837	// 	return false;838	// }839840	/// @dev Not implemented841	/// @dev EVM selector for this function is: 0x7d64bcb4,842	///  or in textual repr: finishMinting()843	function finishMinting() public returns (bool) {844		require(false, stub_error);845		dummy = 0;846		return false;847	}848}849850/// @title Unique extensions for ERC721.851/// @dev the ERC-165 identifier for this interface is 0xabf30dc2852contract ERC721UniqueExtensions is Dummy, ERC165 {853	/// @notice A descriptive name for a collection of NFTs in this contract854	/// @dev EVM selector for this function is: 0x06fdde03,855	///  or in textual repr: name()856	function name() public view returns (string memory) {857		require(false, stub_error);858		dummy;859		return "";860	}861862	/// @notice An abbreviated name for NFTs in this contract863	/// @dev EVM selector for this function is: 0x95d89b41,864	///  or in textual repr: symbol()865	function symbol() public view returns (string memory) {866		require(false, stub_error);867		dummy;868		return "";869	}870871	/// @notice A description for the collection.872	/// @dev EVM selector for this function is: 0x7284e416,873	///  or in textual repr: description()874	function description() public view returns (string memory) {875		require(false, stub_error);876		dummy;877		return "";878	}879880	/// Returns the owner (in cross format) of the token.881	///882	/// @param tokenId Id for the token.883	/// @dev EVM selector for this function is: 0x2b29dace,884	///  or in textual repr: crossOwnerOf(uint256)885	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {886		require(false, stub_error);887		tokenId;888		dummy;889		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);890	}891892	/// Returns the token properties.893	///894	/// @param tokenId Id for the token.895	/// @param keys Properties keys. Empty keys for all propertyes.896	/// @return Vector of properties key/value pairs.897	/// @dev EVM selector for this function is: 0xe07ede7e,898	///  or in textual repr: properties(uint256,string[])899	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {900		require(false, stub_error);901		tokenId;902		keys;903		dummy;904		return new Property[](0);905	}906907	/// @notice Transfer ownership of an RFT908	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`909	///  is the zero address. Throws if `tokenId` is not a valid RFT.910	///  Throws if RFT pieces have multiple owners.911	/// @param to The new owner912	/// @param tokenId The RFT to transfer913	/// @dev EVM selector for this function is: 0xa9059cbb,914	///  or in textual repr: transfer(address,uint256)915	function transfer(address to, uint256 tokenId) public {916		require(false, stub_error);917		to;918		tokenId;919		dummy = 0;920	}921922	/// @notice Transfer ownership of an RFT923	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`924	///  is the zero address. Throws if `tokenId` is not a valid RFT.925	///  Throws if RFT pieces have multiple owners.926	/// @param to The new owner927	/// @param tokenId The RFT to transfer928	/// @dev EVM selector for this function is: 0x2ada85ff,929	///  or in textual repr: transferCross((address,uint256),uint256)930	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {931		require(false, stub_error);932		to;933		tokenId;934		dummy = 0;935	}936937	/// @notice Transfer ownership of an RFT938	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`939	///  is the zero address. Throws if `tokenId` is not a valid RFT.940	///  Throws if RFT pieces have multiple owners.941	/// @param to The new owner942	/// @param tokenId The RFT to transfer943	/// @dev EVM selector for this function is: 0xd5cf430b,944	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)945	function transferFromCross(946		EthCrossAccount memory from,947		EthCrossAccount memory to,948		uint256 tokenId949	) public {950		require(false, stub_error);951		from;952		to;953		tokenId;954		dummy = 0;955	}956957	// /// @notice Burns a specific ERC721 token.958	// /// @dev Throws unless `msg.sender` is the current owner or an authorized959	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws960	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.961	// ///  Throws if RFT pieces have multiple owners.962	// /// @param from The current owner of the RFT963	// /// @param tokenId The RFT to transfer964	// /// @dev EVM selector for this function is: 0x79cc6790,965	// ///  or in textual repr: burnFrom(address,uint256)966	// function burnFrom(address from, uint256 tokenId) public {967	// 	require(false, stub_error);968	// 	from;969	// 	tokenId;970	// 	dummy = 0;971	// }972973	/// @notice Burns a specific ERC721 token.974	/// @dev Throws unless `msg.sender` is the current owner or an authorized975	///  operator for this RFT. Throws if `from` is not the current owner. Throws976	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.977	///  Throws if RFT pieces have multiple owners.978	/// @param from The current owner of the RFT979	/// @param tokenId The RFT to transfer980	/// @dev EVM selector for this function is: 0xbb2f5a58,981	///  or in textual repr: burnFromCross((address,uint256),uint256)982	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {983		require(false, stub_error);984		from;985		tokenId;986		dummy = 0;987	}988989	/// @notice Returns next free RFT ID.990	/// @dev EVM selector for this function is: 0x75794a3c,991	///  or in textual repr: nextTokenId()992	function nextTokenId() public view returns (uint256) {993		require(false, stub_error);994		dummy;995		return 0;996	}997998	// /// @notice Function to mint multiple tokens.999	// /// @dev `tokenIds` should be an array of consecutive numbers and first number1000	// ///  should be obtained with `nextTokenId` method1001	// /// @param to The new owner1002	// /// @param tokenIds IDs of the minted RFTs1003	// /// @dev EVM selector for this function is: 0x44a9945e,1004	// ///  or in textual repr: mintBulk(address,uint256[])1005	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {1006	// 	require(false, stub_error);1007	// 	to;1008	// 	tokenIds;1009	// 	dummy = 0;1010	// 	return false;1011	// }10121013	// /// @notice Function to mint multiple tokens with the given tokenUris.1014	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1015	// ///  numbers and first number should be obtained with `nextTokenId` method1016	// /// @param to The new owner1017	// /// @param tokens array of pairs of token ID and token URI for minted tokens1018	// /// @dev EVM selector for this function is: 0x36543006,1019	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])1020	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {1021	// 	require(false, stub_error);1022	// 	to;1023	// 	tokens;1024	// 	dummy = 0;1025	// 	return false;1026	// }10271028	/// @notice Function to a mint token.1029	/// @param to The new owner crossAccountId1030	/// @param properties Properties of minted token1031	/// @return uint256 The id of the newly minted token1032	/// @dev EVM selector for this function is: 0xb904db03,1033	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])1034	function mintCross(EthCrossAccount memory to, Property[] memory properties) public returns (uint256) {1035		require(false, stub_error);1036		to;1037		properties;1038		dummy = 0;1039		return 0;1040	}10411042	/// Returns EVM address for refungible token1043	///1044	/// @param token ID of the token1045	/// @dev EVM selector for this function is: 0xab76fac6,1046	///  or in textual repr: tokenContractAddress(uint256)1047	function tokenContractAddress(uint256 token) public view returns (address) {1048		require(false, stub_error);1049		token;1050		dummy;1051		return 0x0000000000000000000000000000000000000000;1052	}1053}10541055/// @dev anonymous struct1056struct Tuple14 {1057	uint256 field_0;1058	string field_1;1059}10601061/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1062/// @dev See https://eips.ethereum.org/EIPS/eip-7211063/// @dev the ERC-165 identifier for this interface is 0x780e9d631064contract ERC721Enumerable is Dummy, ERC165 {1065	/// @notice Enumerate valid RFTs1066	/// @param index A counter less than `totalSupply()`1067	/// @return The token identifier for the `index`th NFT,1068	///  (sort order not specified)1069	/// @dev EVM selector for this function is: 0x4f6ccce7,1070	///  or in textual repr: tokenByIndex(uint256)1071	function tokenByIndex(uint256 index) public view returns (uint256) {1072		require(false, stub_error);1073		index;1074		dummy;1075		return 0;1076	}10771078	/// Not implemented1079	/// @dev EVM selector for this function is: 0x2f745c59,1080	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1081	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1082		require(false, stub_error);1083		owner;1084		index;1085		dummy;1086		return 0;1087	}10881089	/// @notice Count RFTs tracked by this contract1090	/// @return A count of valid RFTs tracked by this contract, where each one of1091	///  them has an assigned and queryable owner not equal to the zero address1092	/// @dev EVM selector for this function is: 0x18160ddd,1093	///  or in textual repr: totalSupply()1094	function totalSupply() public view returns (uint256) {1095		require(false, stub_error);1096		dummy;1097		return 0;1098	}1099}11001101/// @dev inlined interface1102contract ERC721Events {1103	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1104	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1105	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1106}11071108/// @title ERC-721 Non-Fungible Token Standard1109/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1110/// @dev the ERC-165 identifier for this interface is 0x4016cd871111contract ERC721 is Dummy, ERC165, ERC721Events {1112	/// @notice Count all RFTs assigned to an owner1113	/// @dev RFTs assigned to the zero address are considered invalid, and this1114	///  function throws for queries about the zero address.1115	/// @param owner An address for whom to query the balance1116	/// @return The number of RFTs owned by `owner`, possibly zero1117	/// @dev EVM selector for this function is: 0x70a08231,1118	///  or in textual repr: balanceOf(address)1119	function balanceOf(address owner) public view returns (uint256) {1120		require(false, stub_error);1121		owner;1122		dummy;1123		return 0;1124	}11251126	/// @notice Find the owner of an RFT1127	/// @dev RFTs assigned to zero address are considered invalid, and queries1128	///  about them do throw.1129	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1130	///  the tokens that are partially owned.1131	/// @param tokenId The identifier for an RFT1132	/// @return The address of the owner of the RFT1133	/// @dev EVM selector for this function is: 0x6352211e,1134	///  or in textual repr: ownerOf(uint256)1135	function ownerOf(uint256 tokenId) public view returns (address) {1136		require(false, stub_error);1137		tokenId;1138		dummy;1139		return 0x0000000000000000000000000000000000000000;1140	}11411142	/// @dev Not implemented1143	/// @dev EVM selector for this function is: 0x60a11672,1144	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)1145	function safeTransferFromWithData(1146		address from,1147		address to,1148		uint256 tokenId,1149		bytes memory data1150	) public {1151		require(false, stub_error);1152		from;1153		to;1154		tokenId;1155		data;1156		dummy = 0;1157	}11581159	/// @dev Not implemented1160	/// @dev EVM selector for this function is: 0x42842e0e,1161	///  or in textual repr: safeTransferFrom(address,address,uint256)1162	function safeTransferFrom(1163		address from,1164		address to,1165		uint256 tokenId1166	) public {1167		require(false, stub_error);1168		from;1169		to;1170		tokenId;1171		dummy = 0;1172	}11731174	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1175	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1176	///  THEY MAY BE PERMANENTLY LOST1177	/// @dev Throws unless `msg.sender` is the current owner or an authorized1178	///  operator for this RFT. Throws if `from` is not the current owner. Throws1179	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1180	///  Throws if RFT pieces have multiple owners.1181	/// @param from The current owner of the NFT1182	/// @param to The new owner1183	/// @param tokenId The NFT to transfer1184	/// @dev EVM selector for this function is: 0x23b872dd,1185	///  or in textual repr: transferFrom(address,address,uint256)1186	function transferFrom(1187		address from,1188		address to,1189		uint256 tokenId1190	) public {1191		require(false, stub_error);1192		from;1193		to;1194		tokenId;1195		dummy = 0;1196	}11971198	/// @dev Not implemented1199	/// @dev EVM selector for this function is: 0x095ea7b3,1200	///  or in textual repr: approve(address,uint256)1201	function approve(address approved, uint256 tokenId) public {1202		require(false, stub_error);1203		approved;1204		tokenId;1205		dummy = 0;1206	}12071208	/// @notice Sets or unsets the approval of a given operator.1209	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1210	/// @param operator Operator1211	/// @param approved Should operator status be granted or revoked?1212	/// @dev EVM selector for this function is: 0xa22cb465,1213	///  or in textual repr: setApprovalForAll(address,bool)1214	function setApprovalForAll(address operator, bool approved) public {1215		require(false, stub_error);1216		operator;1217		approved;1218		dummy = 0;1219	}12201221	/// @dev Not implemented1222	/// @dev EVM selector for this function is: 0x081812fc,1223	///  or in textual repr: getApproved(uint256)1224	function getApproved(uint256 tokenId) public view returns (address) {1225		require(false, stub_error);1226		tokenId;1227		dummy;1228		return 0x0000000000000000000000000000000000000000;1229	}12301231	/// @notice Tells whether the given `owner` approves the `operator`.1232	/// @dev EVM selector for this function is: 0xe985e9c5,1233	///  or in textual repr: isApprovedForAll(address,address)1234	function isApprovedForAll(address owner, address operator) public view returns (bool) {1235		require(false, stub_error);1236		owner;1237		operator;1238		dummy;1239		return false;1240	}12411242	/// @notice Returns collection helper contract address1243	/// @dev EVM selector for this function is: 0x1896cce6,1244	///  or in textual repr: collectionHelperAddress()1245	function collectionHelperAddress() public view returns (address) {1246		require(false, stub_error);1247		dummy;1248		return 0x0000000000000000000000000000000000000000;1249	}1250}12511252contract UniqueRefungible is1253	Dummy,1254	ERC165,1255	ERC721,1256	ERC721Enumerable,1257	ERC721UniqueExtensions,1258	ERC721UniqueMintable,1259	ERC721Burnable,1260	ERC721Metadata,1261	Collection,1262	TokenProperties1263{}