git.delta.rocks / unique-network / refs/commits / 5223dbed88c4

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 0x91a97a6822contract 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(32		string memory key,33		bool isMutable,34		bool collectionAdmin,35		bool tokenOwner36	) public {37		require(false, stub_error);38		key;39		isMutable;40		collectionAdmin;41		tokenOwner;42		dummy = 0;43	}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) public {53	// 	require(false, stub_error);54	// 	tokenId;55	// 	key;56	// 	value;57	// 	dummy = 0;58	// }5960	/// @notice Set token properties value.61	/// @dev Throws error if `msg.sender` has no permission to edit the property.62	/// @param tokenId ID of the token.63	/// @param properties settable properties64	/// @dev EVM selector for this function is: 0x14ed3a6e,65	///  or in textual repr: setProperties(uint256,(string,bytes)[])66	function setProperties(uint256 tokenId, Property[] memory properties) public {67		require(false, stub_error);68		tokenId;69		properties;70		dummy = 0;71	}7273	// /// @notice Delete token property value.74	// /// @dev Throws error if `msg.sender` has no permission to edit the property.75	// /// @param tokenId ID of the token.76	// /// @param key Property key.77	// /// @dev EVM selector for this function is: 0x066111d1,78	// ///  or in textual repr: deleteProperty(uint256,string)79	// function deleteProperty(uint256 tokenId, string memory key) public {80	// 	require(false, stub_error);81	// 	tokenId;82	// 	key;83	// 	dummy = 0;84	// }8586	/// @notice Delete 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 keys Properties key.90	/// @dev EVM selector for this function is: 0xc472d371,91	///  or in textual repr: deleteProperties(uint256,string[])92	function deleteProperties(uint256 tokenId, string[] memory keys) public {93		require(false, stub_error);94		tokenId;95		keys;96		dummy = 0;97	}9899	/// @notice Get token property value.100	/// @dev Throws error if key not found101	/// @param tokenId ID of the token.102	/// @param key Property key.103	/// @return Property value bytes104	/// @dev EVM selector for this function is: 0x7228c327,105	///  or in textual repr: property(uint256,string)106	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107		require(false, stub_error);108		tokenId;109		key;110		dummy;111		return hex"";112	}113}114115/// @dev Property struct116struct Property {117	string key;118	bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0xeecfdb34123contract Collection is Dummy, ERC165 {124	// /// Set collection property.125	// ///126	// /// @param key Property key.127	// /// @param value Propery value.128	// /// @dev EVM selector for this function is: 0x2f073f66,129	// ///  or in textual repr: setCollectionProperty(string,bytes)130	// function setCollectionProperty(string memory key, bytes memory value) public {131	// 	require(false, stub_error);132	// 	key;133	// 	value;134	// 	dummy = 0;135	// }136137	/// Set collection properties.138	///139	/// @param properties Vector of properties key/value pair.140	/// @dev EVM selector for this function is: 0x50b26b2a,141	///  or in textual repr: setCollectionProperties((string,bytes)[])142	function setCollectionProperties(Property[] memory properties) public {143		require(false, stub_error);144		properties;145		dummy = 0;146	}147148	// /// Delete collection property.149	// ///150	// /// @param key Property key.151	// /// @dev EVM selector for this function is: 0x7b7debce,152	// ///  or in textual repr: deleteCollectionProperty(string)153	// function deleteCollectionProperty(string memory key) public {154	// 	require(false, stub_error);155	// 	key;156	// 	dummy = 0;157	// }158159	/// Delete collection properties.160	///161	/// @param keys Properties keys.162	/// @dev EVM selector for this function is: 0xee206ee3,163	///  or in textual repr: deleteCollectionProperties(string[])164	function deleteCollectionProperties(string[] memory keys) public {165		require(false, stub_error);166		keys;167		dummy = 0;168	}169170	/// Get collection property.171	///172	/// @dev Throws error if key not found.173	///174	/// @param key Property key.175	/// @return bytes The property corresponding to the key.176	/// @dev EVM selector for this function is: 0xcf24fd6d,177	///  or in textual repr: collectionProperty(string)178	function collectionProperty(string memory key) public view returns (bytes memory) {179		require(false, stub_error);180		key;181		dummy;182		return hex"";183	}184185	/// Get collection properties.186	///187	/// @param keys Properties keys. Empty keys for all propertyes.188	/// @return Vector of properties key/value pairs.189	/// @dev EVM selector for this function is: 0x285fb8e6,190	///  or in textual repr: collectionProperties(string[])191	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {192		require(false, stub_error);193		keys;194		dummy;195		return new Property[](0);196	}197198	// /// Set the sponsor of the collection.199	// ///200	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201	// ///202	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203	// /// @dev EVM selector for this function is: 0x7623402e,204	// ///  or in textual repr: setCollectionSponsor(address)205	// function setCollectionSponsor(address sponsor) public {206	// 	require(false, stub_error);207	// 	sponsor;208	// 	dummy = 0;209	// }210211	/// Set the sponsor of the collection.212	///213	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214	///215	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216	/// @dev EVM selector for this function is: 0x84a1d5a8,217	///  or in textual repr: setCollectionSponsorCross((address,uint256))218	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219		require(false, stub_error);220		sponsor;221		dummy = 0;222	}223224	/// Whether there is a pending sponsor.225	/// @dev EVM selector for this function is: 0x058ac185,226	///  or in textual repr: hasCollectionPendingSponsor()227	function hasCollectionPendingSponsor() public view returns (bool) {228		require(false, stub_error);229		dummy;230		return false;231	}232233	/// Collection sponsorship confirmation.234	///235	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.236	/// @dev EVM selector for this function is: 0x3c50e97a,237	///  or in textual repr: confirmCollectionSponsorship()238	function confirmCollectionSponsorship() public {239		require(false, stub_error);240		dummy = 0;241	}242243	/// Remove collection sponsor.244	/// @dev EVM selector for this function is: 0x6e0326a3,245	///  or in textual repr: removeCollectionSponsor()246	function removeCollectionSponsor() public {247		require(false, stub_error);248		dummy = 0;249	}250251	/// Get current sponsor.252	///253	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254	/// @dev EVM selector for this function is: 0x6ec0a9f1,255	///  or in textual repr: collectionSponsor()256	function collectionSponsor() public view returns (Tuple30 memory) {257		require(false, stub_error);258		dummy;259		return Tuple30(0x0000000000000000000000000000000000000000, 0);260	}261262	/// Set limits for the collection.263	/// @dev Throws error if limit not found.264	/// @param limit Name of the limit. Valid names:265	/// 	"accountTokenOwnershipLimit",266	/// 	"sponsoredDataSize",267	/// 	"sponsoredDataRateLimit",268	/// 	"tokenLimit",269	/// 	"sponsorTransferTimeout",270	/// 	"sponsorApproveTimeout"271	///  	"ownerCanTransfer",272	/// 	"ownerCanDestroy",273	/// 	"transfersEnabled"274	/// @param value Value of the limit.275	/// @dev EVM selector for this function is: 0x4ad890a8,276	///  or in textual repr: setCollectionLimit(string,uint256)277	function setCollectionLimit(string memory limit, uint256 value) public {278		require(false, stub_error);279		limit;280		value;281		dummy = 0;282	}283284	/// Get contract address.285	/// @dev EVM selector for this function is: 0xf6b4dfb4,286	///  or in textual repr: contractAddress()287	function contractAddress() public view returns (address) {288		require(false, stub_error);289		dummy;290		return 0x0000000000000000000000000000000000000000;291	}292293	/// Add collection admin.294	/// @param newAdmin Cross account administrator address.295	/// @dev EVM selector for this function is: 0x859aa7d6,296	///  or in textual repr: addCollectionAdminCross((address,uint256))297	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {298		require(false, stub_error);299		newAdmin;300		dummy = 0;301	}302303	/// Remove collection admin.304	/// @param admin Cross account administrator address.305	/// @dev EVM selector for this function is: 0x6c0cd173,306	///  or in textual repr: removeCollectionAdminCross((address,uint256))307	function removeCollectionAdminCross(EthCrossAccount memory admin) public {308		require(false, stub_error);309		admin;310		dummy = 0;311	}312313	// /// Add collection admin.314	// /// @param newAdmin Address of the added administrator.315	// /// @dev EVM selector for this function is: 0x92e462c7,316	// ///  or in textual repr: addCollectionAdmin(address)317	// function addCollectionAdmin(address newAdmin) public {318	// 	require(false, stub_error);319	// 	newAdmin;320	// 	dummy = 0;321	// }322323	// /// Remove collection admin.324	// ///325	// /// @param admin Address of the removed administrator.326	// /// @dev EVM selector for this function is: 0xfafd7b42,327	// ///  or in textual repr: removeCollectionAdmin(address)328	// function removeCollectionAdmin(address admin) public {329	// 	require(false, stub_error);330	// 	admin;331	// 	dummy = 0;332	// }333334	/// Toggle accessibility of collection nesting.335	///336	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'337	/// @dev EVM selector for this function is: 0x112d4586,338	///  or in textual repr: setCollectionNesting(bool)339	function setCollectionNesting(bool enable) public {340		require(false, stub_error);341		enable;342		dummy = 0;343	}344345	/// Toggle accessibility of collection nesting.346	///347	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'348	/// @param collections Addresses of collections that will be available for nesting.349	/// @dev EVM selector for this function is: 0x64872396,350	///  or in textual repr: setCollectionNesting(bool,address[])351	function setCollectionNesting(bool enable, address[] memory collections) public {352		require(false, stub_error);353		enable;354		collections;355		dummy = 0;356	}357358	/// Returns nesting for a collection359	/// @dev EVM selector for this function is: 0x22d25bfe,360	///  or in textual repr: collectionNestingRestrictedCollectionIds()361	function collectionNestingRestrictedCollectionIds() public view returns (Tuple34 memory) {362		require(false, stub_error);363		dummy;364		return Tuple34(false, new uint256[](0));365	}366367	/// Set the collection access method.368	/// @param mode Access mode369	/// 	0 for Normal370	/// 	1 for AllowList371	/// @dev EVM selector for this function is: 0x41835d4c,372	///  or in textual repr: setCollectionAccess(uint8)373	function setCollectionAccess(uint8 mode) public {374		require(false, stub_error);375		mode;376		dummy = 0;377	}378379	/// Checks that user allowed to operate with collection.380	///381	/// @param user User address to check.382	/// @dev EVM selector for this function is: 0x91b6df49,383	///  or in textual repr: allowlistedCross((address,uint256))384	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {385		require(false, stub_error);386		user;387		dummy;388		return false;389	}390391	// /// Add the user to the allowed list.392	// ///393	// /// @param user Address of a trusted user.394	// /// @dev EVM selector for this function is: 0x67844fe6,395	// ///  or in textual repr: addToCollectionAllowList(address)396	// function addToCollectionAllowList(address user) public {397	// 	require(false, stub_error);398	// 	user;399	// 	dummy = 0;400	// }401402	/// Add user to allowed list.403	///404	/// @param user User cross account address.405	/// @dev EVM selector for this function is: 0xa0184a3a,406	///  or in textual repr: addToCollectionAllowListCross((address,uint256))407	function addToCollectionAllowListCross(EthCrossAccount memory user) public {408		require(false, stub_error);409		user;410		dummy = 0;411	}412413	// /// Remove the user from the allowed list.414	// ///415	// /// @param user Address of a removed user.416	// /// @dev EVM selector for this function is: 0x85c51acb,417	// ///  or in textual repr: removeFromCollectionAllowList(address)418	// function removeFromCollectionAllowList(address user) public {419	// 	require(false, stub_error);420	// 	user;421	// 	dummy = 0;422	// }423424	/// Remove user from allowed list.425	///426	/// @param user User cross account address.427	/// @dev EVM selector for this function is: 0x09ba452a,428	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))429	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {430		require(false, stub_error);431		user;432		dummy = 0;433	}434435	/// Switch permission for minting.436	///437	/// @param mode Enable if "true".438	/// @dev EVM selector for this function is: 0x00018e84,439	///  or in textual repr: setCollectionMintMode(bool)440	function setCollectionMintMode(bool mode) public {441		require(false, stub_error);442		mode;443		dummy = 0;444	}445446	// /// Check that account is the owner or admin of the collection447	// ///448	// /// @param user account to verify449	// /// @return "true" if account is the owner or admin450	// /// @dev EVM selector for this function is: 0x9811b0c7,451	// ///  or in textual repr: isOwnerOrAdmin(address)452	// function isOwnerOrAdmin(address user) public view returns (bool) {453	// 	require(false, stub_error);454	// 	user;455	// 	dummy;456	// 	return false;457	// }458459	/// Check that account is the owner or admin of the collection460	///461	/// @param user User cross account to verify462	/// @return "true" if account is the owner or admin463	/// @dev EVM selector for this function is: 0x3e75a905,464	///  or in textual repr: isOwnerOrAdminCross((address,uint256))465	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {466		require(false, stub_error);467		user;468		dummy;469		return false;470	}471472	/// Returns collection type473	///474	/// @return `Fungible` or `NFT` or `ReFungible`475	/// @dev EVM selector for this function is: 0xd34b55b8,476	///  or in textual repr: uniqueCollectionType()477	function uniqueCollectionType() public view returns (string memory) {478		require(false, stub_error);479		dummy;480		return "";481	}482483	/// Get collection owner.484	///485	/// @return Tuble with sponsor address and his substrate mirror.486	/// If address is canonical then substrate mirror is zero and vice versa.487	/// @dev EVM selector for this function is: 0xdf727d3b,488	///  or in textual repr: collectionOwner()489	function collectionOwner() public view returns (EthCrossAccount memory) {490		require(false, stub_error);491		dummy;492		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);493	}494495	// /// Changes collection owner to another account496	// ///497	// /// @dev Owner can be changed only by current owner498	// /// @param newOwner new owner account499	// /// @dev EVM selector for this function is: 0x4f53e226,500	// ///  or in textual repr: changeCollectionOwner(address)501	// function changeCollectionOwner(address newOwner) public {502	// 	require(false, stub_error);503	// 	newOwner;504	// 	dummy = 0;505	// }506507	/// Get collection administrators508	///509	/// @return Vector of tuples with admins address and his substrate mirror.510	/// If address is canonical then substrate mirror is zero and vice versa.511	/// @dev EVM selector for this function is: 0x5813216b,512	///  or in textual repr: collectionAdmins()513	function collectionAdmins() public view returns (EthCrossAccount[] memory) {514		require(false, stub_error);515		dummy;516		return new EthCrossAccount[](0);517	}518519	/// Changes collection owner to another account520	///521	/// @dev Owner can be changed only by current owner522	/// @param newOwner new owner cross account523	/// @dev EVM selector for this function is: 0x6496c497,524	///  or in textual repr: changeCollectionOwnerCross((address,uint256))525	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {526		require(false, stub_error);527		newOwner;528		dummy = 0;529	}530}531532/// @dev Cross account struct533struct EthCrossAccount {534	address eth;535	uint256 sub;536}537538/// @dev anonymous struct539struct Tuple34 {540	bool field_0;541	uint256[] field_1;542}543544/// @dev anonymous struct545struct Tuple30 {546	address field_0;547	uint256 field_1;548}549550/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension551/// @dev See https://eips.ethereum.org/EIPS/eip-721552/// @dev the ERC-165 identifier for this interface is 0x5b5e139f553contract ERC721Metadata is Dummy, ERC165 {554	// /// @notice A descriptive name for a collection of NFTs in this contract555	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`556	// /// @dev EVM selector for this function is: 0x06fdde03,557	// ///  or in textual repr: name()558	// function name() public view returns (string memory) {559	// 	require(false, stub_error);560	// 	dummy;561	// 	return "";562	// }563564	// /// @notice An abbreviated name for NFTs in this contract565	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`566	// /// @dev EVM selector for this function is: 0x95d89b41,567	// ///  or in textual repr: symbol()568	// function symbol() public view returns (string memory) {569	// 	require(false, stub_error);570	// 	dummy;571	// 	return "";572	// }573574	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.575	///576	/// @dev If the token has a `url` property and it is not empty, it is returned.577	///  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`.578	///  If the collection property `baseURI` is empty or absent, return "" (empty string)579	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix580	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).581	///582	/// @return token's const_metadata583	/// @dev EVM selector for this function is: 0xc87b56dd,584	///  or in textual repr: tokenURI(uint256)585	function tokenURI(uint256 tokenId) public view returns (string memory) {586		require(false, stub_error);587		tokenId;588		dummy;589		return "";590	}591}592593/// @title ERC721 Token that can be irreversibly burned (destroyed).594/// @dev the ERC-165 identifier for this interface is 0x42966c68595contract ERC721Burnable is Dummy, ERC165 {596	/// @notice Burns a specific ERC721 token.597	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized598	///  operator of the current owner.599	/// @param tokenId The NFT to approve600	/// @dev EVM selector for this function is: 0x42966c68,601	///  or in textual repr: burn(uint256)602	function burn(uint256 tokenId) public {603		require(false, stub_error);604		tokenId;605		dummy = 0;606	}607}608609/// @dev inlined interface610contract ERC721UniqueMintableEvents {611	event MintingFinished();612}613614/// @title ERC721 minting logic.615/// @dev the ERC-165 identifier for this interface is 0x476ff149616contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {617	/// @dev EVM selector for this function is: 0x05d2035b,618	///  or in textual repr: mintingFinished()619	function mintingFinished() public view returns (bool) {620		require(false, stub_error);621		dummy;622		return false;623	}624625	/// @notice Function to mint token.626	/// @param to The new owner627	/// @return uint256 The id of the newly minted token628	/// @dev EVM selector for this function is: 0x6a627842,629	///  or in textual repr: mint(address)630	function mint(address to) public returns (uint256) {631		require(false, stub_error);632		to;633		dummy = 0;634		return 0;635	}636637	// /// @notice Function to mint token.638	// /// @dev `tokenId` should be obtained with `nextTokenId` method,639	// ///  unlike standard, you can't specify it manually640	// /// @param to The new owner641	// /// @param tokenId ID of the minted NFT642	// /// @dev EVM selector for this function is: 0x40c10f19,643	// ///  or in textual repr: mint(address,uint256)644	// function mint(address to, uint256 tokenId) public returns (bool) {645	// 	require(false, stub_error);646	// 	to;647	// 	tokenId;648	// 	dummy = 0;649	// 	return false;650	// }651652	/// @notice Function to mint token with the given tokenUri.653	/// @param to The new owner654	/// @param tokenUri Token URI that would be stored in the NFT properties655	/// @return uint256 The id of the newly minted token656	/// @dev EVM selector for this function is: 0x45c17782,657	///  or in textual repr: mintWithTokenURI(address,string)658	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {659		require(false, stub_error);660		to;661		tokenUri;662		dummy = 0;663		return 0;664	}665666	// /// @notice Function to mint token with the given tokenUri.667	// /// @dev `tokenId` should be obtained with `nextTokenId` method,668	// ///  unlike standard, you can't specify it manually669	// /// @param to The new owner670	// /// @param tokenId ID of the minted NFT671	// /// @param tokenUri Token URI that would be stored in the NFT properties672	// /// @dev EVM selector for this function is: 0x50bb4e7f,673	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)674	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {675	// 	require(false, stub_error);676	// 	to;677	// 	tokenId;678	// 	tokenUri;679	// 	dummy = 0;680	// 	return false;681	// }682683	/// @dev Not implemented684	/// @dev EVM selector for this function is: 0x7d64bcb4,685	///  or in textual repr: finishMinting()686	function finishMinting() public returns (bool) {687		require(false, stub_error);688		dummy = 0;689		return false;690	}691}692693/// @title Unique extensions for ERC721.694/// @dev the ERC-165 identifier for this interface is 0xb74c26b7695contract ERC721UniqueExtensions is Dummy, ERC165 {696	/// @notice A descriptive name for a collection of NFTs in this contract697	/// @dev EVM selector for this function is: 0x06fdde03,698	///  or in textual repr: name()699	function name() public view returns (string memory) {700		require(false, stub_error);701		dummy;702		return "";703	}704705	/// @notice An abbreviated name for NFTs in this contract706	/// @dev EVM selector for this function is: 0x95d89b41,707	///  or in textual repr: symbol()708	function symbol() public view returns (string memory) {709		require(false, stub_error);710		dummy;711		return "";712	}713714	/// @notice A description for the collection.715	/// @dev EVM selector for this function is: 0x7284e416,716	///  or in textual repr: description()717	function description() public view returns (string memory) {718		require(false, stub_error);719		dummy;720		return "";721	}722723	/// Returns the owner (in cross format) of the token.724	///725	/// @param tokenId Id for the token.726	/// @dev EVM selector for this function is: 0x2b29dace,727	///  or in textual repr: crossOwnerOf(uint256)728	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {729		require(false, stub_error);730		tokenId;731		dummy;732		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);733	}734735	/// Returns the token properties.736	///737	/// @param tokenId Id for the token.738	/// @param keys Properties keys. Empty keys for all propertyes.739	/// @return Vector of properties key/value pairs.740	/// @dev EVM selector for this function is: 0xe07ede7e,741	///  or in textual repr: properties(uint256,string[])742	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {743		require(false, stub_error);744		tokenId;745		keys;746		dummy;747		return new Property[](0);748	}749750	/// @notice Set or reaffirm the approved address for an NFT751	/// @dev The zero address indicates there is no approved address.752	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized753	///  operator of the current owner.754	/// @param approved The new substrate address approved NFT controller755	/// @param tokenId The NFT to approve756	/// @dev EVM selector for this function is: 0x0ecd0ab0,757	///  or in textual repr: approveCross((address,uint256),uint256)758	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {759		require(false, stub_error);760		approved;761		tokenId;762		dummy = 0;763	}764765	/// @notice Transfer ownership of an NFT766	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`767	///  is the zero address. Throws if `tokenId` is not a valid NFT.768	/// @param to The new owner769	/// @param tokenId The NFT to transfer770	/// @dev EVM selector for this function is: 0xa9059cbb,771	///  or in textual repr: transfer(address,uint256)772	function transfer(address to, uint256 tokenId) public {773		require(false, stub_error);774		to;775		tokenId;776		dummy = 0;777	}778779	/// @notice Transfer ownership of an NFT780	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`781	///  is the zero address. Throws if `tokenId` is not a valid NFT.782	/// @param to The new owner783	/// @param tokenId The NFT to transfer784	/// @dev EVM selector for this function is: 0x2ada85ff,785	///  or in textual repr: transferCross((address,uint256),uint256)786	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {787		require(false, stub_error);788		to;789		tokenId;790		dummy = 0;791	}792793	/// @notice Transfer ownership of an NFT from cross account address to cross account address794	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`795	///  is the zero address. Throws if `tokenId` is not a valid NFT.796	/// @param from Cross acccount address of current owner797	/// @param to Cross acccount address of new owner798	/// @param tokenId The NFT to transfer799	/// @dev EVM selector for this function is: 0xd5cf430b,800	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)801	function transferFromCross(802		EthCrossAccount memory from,803		EthCrossAccount memory to,804		uint256 tokenId805	) public {806		require(false, stub_error);807		from;808		to;809		tokenId;810		dummy = 0;811	}812813	// /// @notice Burns a specific ERC721 token.814	// /// @dev Throws unless `msg.sender` is the current owner or an authorized815	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws816	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.817	// /// @param from The current owner of the NFT818	// /// @param tokenId The NFT to transfer819	// /// @dev EVM selector for this function is: 0x79cc6790,820	// ///  or in textual repr: burnFrom(address,uint256)821	// function burnFrom(address from, uint256 tokenId) public {822	// 	require(false, stub_error);823	// 	from;824	// 	tokenId;825	// 	dummy = 0;826	// }827828	/// @notice Burns a specific ERC721 token.829	/// @dev Throws unless `msg.sender` is the current owner or an authorized830	///  operator for this NFT. Throws if `from` is not the current owner. Throws831	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.832	/// @param from The current owner of the NFT833	/// @param tokenId The NFT to transfer834	/// @dev EVM selector for this function is: 0xbb2f5a58,835	///  or in textual repr: burnFromCross((address,uint256),uint256)836	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {837		require(false, stub_error);838		from;839		tokenId;840		dummy = 0;841	}842843	/// @notice Returns next free NFT ID.844	/// @dev EVM selector for this function is: 0x75794a3c,845	///  or in textual repr: nextTokenId()846	function nextTokenId() public view returns (uint256) {847		require(false, stub_error);848		dummy;849		return 0;850	}851	// /// @notice Function to mint multiple tokens.852	// /// @dev `tokenIds` should be an array of consecutive numbers and first number853	// ///  should be obtained with `nextTokenId` method854	// /// @param to The new owner855	// /// @param tokenIds IDs of the minted NFTs856	// /// @dev EVM selector for this function is: 0x44a9945e,857	// ///  or in textual repr: mintBulk(address,uint256[])858	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {859	// 	require(false, stub_error);860	// 	to;861	// 	tokenIds;862	// 	dummy = 0;863	// 	return false;864	// }865866	// /// @notice Function to mint multiple tokens with the given tokenUris.867	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive868	// ///  numbers and first number should be obtained with `nextTokenId` method869	// /// @param to The new owner870	// /// @param tokens array of pairs of token ID and token URI for minted tokens871	// /// @dev EVM selector for this function is: 0x36543006,872	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])873	// function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {874	// 	require(false, stub_error);875	// 	to;876	// 	tokens;877	// 	dummy = 0;878	// 	return false;879	// }880881}882883/// @dev anonymous struct884struct Tuple15 {885	uint256 field_0;886	string field_1;887}888889/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension890/// @dev See https://eips.ethereum.org/EIPS/eip-721891/// @dev the ERC-165 identifier for this interface is 0x780e9d63892contract ERC721Enumerable is Dummy, ERC165 {893	/// @notice Enumerate valid NFTs894	/// @param index A counter less than `totalSupply()`895	/// @return The token identifier for the `index`th NFT,896	///  (sort order not specified)897	/// @dev EVM selector for this function is: 0x4f6ccce7,898	///  or in textual repr: tokenByIndex(uint256)899	function tokenByIndex(uint256 index) public view returns (uint256) {900		require(false, stub_error);901		index;902		dummy;903		return 0;904	}905906	/// @dev Not implemented907	/// @dev EVM selector for this function is: 0x2f745c59,908	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)909	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {910		require(false, stub_error);911		owner;912		index;913		dummy;914		return 0;915	}916917	/// @notice Count NFTs tracked by this contract918	/// @return A count of valid NFTs tracked by this contract, where each one of919	///  them has an assigned and queryable owner not equal to the zero address920	/// @dev EVM selector for this function is: 0x18160ddd,921	///  or in textual repr: totalSupply()922	function totalSupply() public view returns (uint256) {923		require(false, stub_error);924		dummy;925		return 0;926	}927}928929/// @dev inlined interface930contract ERC721Events {931	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);932	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);933	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);934}935936/// @title ERC-721 Non-Fungible Token Standard937/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md938/// @dev the ERC-165 identifier for this interface is 0x983a942b939contract ERC721 is Dummy, ERC165, ERC721Events {940	/// @notice Count all NFTs assigned to an owner941	/// @dev NFTs assigned to the zero address are considered invalid, and this942	///  function throws for queries about the zero address.943	/// @param owner An address for whom to query the balance944	/// @return The number of NFTs owned by `owner`, possibly zero945	/// @dev EVM selector for this function is: 0x70a08231,946	///  or in textual repr: balanceOf(address)947	function balanceOf(address owner) public view returns (uint256) {948		require(false, stub_error);949		owner;950		dummy;951		return 0;952	}953954	/// @notice Find the owner of an NFT955	/// @dev NFTs assigned to zero address are considered invalid, and queries956	///  about them do throw.957	/// @param tokenId The identifier for an NFT958	/// @return The address of the owner of the NFT959	/// @dev EVM selector for this function is: 0x6352211e,960	///  or in textual repr: ownerOf(uint256)961	function ownerOf(uint256 tokenId) public view returns (address) {962		require(false, stub_error);963		tokenId;964		dummy;965		return 0x0000000000000000000000000000000000000000;966	}967968	/// @dev Not implemented969	/// @dev EVM selector for this function is: 0xb88d4fde,970	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)971	function safeTransferFrom(972		address from,973		address to,974		uint256 tokenId,975		bytes memory data976	) public {977		require(false, stub_error);978		from;979		to;980		tokenId;981		data;982		dummy = 0;983	}984985	/// @dev Not implemented986	/// @dev EVM selector for this function is: 0x42842e0e,987	///  or in textual repr: safeTransferFrom(address,address,uint256)988	function safeTransferFrom(989		address from,990		address to,991		uint256 tokenId992	) public {993		require(false, stub_error);994		from;995		to;996		tokenId;997		dummy = 0;998	}9991000	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1001	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1002	///  THEY MAY BE PERMANENTLY LOST1003	/// @dev Throws unless `msg.sender` is the current owner or an authorized1004	///  operator for this NFT. Throws if `from` is not the current owner. Throws1005	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1006	/// @param from The current owner of the NFT1007	/// @param to The new owner1008	/// @param tokenId The NFT to transfer1009	/// @dev EVM selector for this function is: 0x23b872dd,1010	///  or in textual repr: transferFrom(address,address,uint256)1011	function transferFrom(1012		address from,1013		address to,1014		uint256 tokenId1015	) public {1016		require(false, stub_error);1017		from;1018		to;1019		tokenId;1020		dummy = 0;1021	}10221023	/// @notice Set or reaffirm the approved address for an NFT1024	/// @dev The zero address indicates there is no approved address.1025	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1026	///  operator of the current owner.1027	/// @param approved The new approved NFT controller1028	/// @param tokenId The NFT to approve1029	/// @dev EVM selector for this function is: 0x095ea7b3,1030	///  or in textual repr: approve(address,uint256)1031	function approve(address approved, uint256 tokenId) public {1032		require(false, stub_error);1033		approved;1034		tokenId;1035		dummy = 0;1036	}10371038	/// @notice Sets or unsets the approval of a given operator.1039	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1040	/// @param operator Operator1041	/// @param approved Should operator status be granted or revoked?1042	/// @dev EVM selector for this function is: 0xa22cb465,1043	///  or in textual repr: setApprovalForAll(address,bool)1044	function setApprovalForAll(address operator, bool approved) public {1045		require(false, stub_error);1046		operator;1047		approved;1048		dummy = 0;1049	}10501051	/// @dev Not implemented1052	/// @dev EVM selector for this function is: 0x081812fc,1053	///  or in textual repr: getApproved(uint256)1054	function getApproved(uint256 tokenId) public view returns (address) {1055		require(false, stub_error);1056		tokenId;1057		dummy;1058		return 0x0000000000000000000000000000000000000000;1059	}10601061	/// @notice Tells whether the given `owner` approves the `operator`.1062	/// @dev EVM selector for this function is: 0xe985e9c5,1063	///  or in textual repr: isApprovedForAll(address,address)1064	function isApprovedForAll(address owner, address operator) public view returns (bool) {1065		require(false, stub_error);1066		owner;1067		operator;1068		dummy;1069		return false;1070	}10711072	/// @notice Returns collection helper contract address1073	/// @dev EVM selector for this function is: 0x1896cce6,1074	///  or in textual repr: collectionHelperAddress()1075	function collectionHelperAddress() public view returns (address) {1076		require(false, stub_error);1077		dummy;1078		return 0x0000000000000000000000000000000000000000;1079	}1080}10811082contract UniqueNFT is1083	Dummy,1084	ERC165,1085	ERC721,1086	ERC721Enumerable,1087	ERC721UniqueExtensions,1088	ERC721UniqueMintable,1089	ERC721Burnable,1090	ERC721Metadata,1091	Collection,1092	TokenProperties1093{}