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

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(Tuple59[] memory permissions) public {47=======48	function setTokenPropertyPermissions(Tuple56[] 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 (Tuple59[] memory) {60		require(false, stub_error);61		dummy;62		return new Tuple59[](0);63=======64	function tokenPropertyPermissions() public view returns (Tuple56[] memory) {65		require(false, stub_error);66		dummy;67		return new Tuple56[](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 Tuple59 {160	string field_0;161	Tuple57[] field_1;162}163164/// @dev anonymous struct165struct Tuple57 {166=======167struct Tuple56 {168	string field_0;169	Tuple54[] field_1;170}171172/// @dev anonymous struct173struct Tuple54 {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 (Tuple33[] memory) {336		require(false, stub_error);337		dummy;338		return new Tuple33[](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 (Tuple39 memory) {448		require(false, stub_error);449		dummy;450		return Tuple39(false, new uint256[](0));451=======452	function collectionNestingRestrictedCollectionIds() public view returns (Tuple36 memory) {453		require(false, stub_error);454		dummy;455		return Tuple36(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 (Tuple42[] memory) {464		require(false, stub_error);465		dummy;466		return new Tuple42[](0);467=======468	function collectionNestingPermissions() public view returns (Tuple39[] memory) {469		require(false, stub_error);470		dummy;471		return new Tuple39[](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 Tuple42 {654=======655struct Tuple39 {656>>>>>>> 09f69700... chore: generate stubs657	CollectionPermissions field_0;658	bool field_1;659}660661/// @dev anonymous struct662<<<<<<< HEAD663struct Tuple39 {664=======665struct Tuple36 {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 Tuple33 {696	CollectionLimits field_0;697	bool field_1;698	uint256 field_2;699}700701/// @dev anonymous struct702struct Tuple32 {703	address field_0;704	uint256 field_1;705}706707=======708>>>>>>> 0bf15e6f... fixed tests&tuple instead of struct, refactored `refungible` pallet709=======710>>>>>>> 09f69700... chore: generate stubs711/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension712/// @dev See https://eips.ethereum.org/EIPS/eip-721713/// @dev the ERC-165 identifier for this interface is 0x5b5e139f714contract ERC721Metadata is Dummy, ERC165 {715	// /// @notice A descriptive name for a collection of NFTs in this contract716	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`717	// /// @dev EVM selector for this function is: 0x06fdde03,718	// ///  or in textual repr: name()719	// function name() public view returns (string memory) {720	// 	require(false, stub_error);721	// 	dummy;722	// 	return "";723	// }724725	// /// @notice An abbreviated name for NFTs in this contract726	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`727	// /// @dev EVM selector for this function is: 0x95d89b41,728	// ///  or in textual repr: symbol()729	// function symbol() public view returns (string memory) {730	// 	require(false, stub_error);731	// 	dummy;732	// 	return "";733	// }734735	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.736	///737	/// @dev If the token has a `url` property and it is not empty, it is returned.738	///  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`.739	///  If the collection property `baseURI` is empty or absent, return "" (empty string)740	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix741	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).742	///743	/// @return token's const_metadata744	/// @dev EVM selector for this function is: 0xc87b56dd,745	///  or in textual repr: tokenURI(uint256)746	function tokenURI(uint256 tokenId) public view returns (string memory) {747		require(false, stub_error);748		tokenId;749		dummy;750		return "";751	}752}753754/// @title ERC721 Token that can be irreversibly burned (destroyed).755/// @dev the ERC-165 identifier for this interface is 0x42966c68756contract ERC721Burnable is Dummy, ERC165 {757	/// @notice Burns a specific ERC721 token.758	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized759	///  operator of the current owner.760	/// @param tokenId The NFT to approve761	/// @dev EVM selector for this function is: 0x42966c68,762	///  or in textual repr: burn(uint256)763	function burn(uint256 tokenId) public {764		require(false, stub_error);765		tokenId;766		dummy = 0;767	}768}769770/// @dev inlined interface771contract ERC721UniqueMintableEvents {772	event MintingFinished();773}774775/// @title ERC721 minting logic.776/// @dev the ERC-165 identifier for this interface is 0x476ff149777contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {778	/// @dev EVM selector for this function is: 0x05d2035b,779	///  or in textual repr: mintingFinished()780	function mintingFinished() public view returns (bool) {781		require(false, stub_error);782		dummy;783		return false;784	}785786	/// @notice Function to a mint token.787	/// @param to The new owner788	/// @return uint256 The id of the newly minted token789	/// @dev EVM selector for this function is: 0x6a627842,790	///  or in textual repr: mint(address)791	function mint(address to) public returns (uint256) {792		require(false, stub_error);793		to;794		dummy = 0;795		return 0;796	}797798	// /// @notice Function to a mint token.799	// /// @dev `tokenId` should be obtained with `nextTokenId` method,800	// ///  unlike standard, you can't specify it manually801	// /// @param to The new owner802	// /// @param tokenId ID of the minted NFT803	// /// @dev EVM selector for this function is: 0x40c10f19,804	// ///  or in textual repr: mint(address,uint256)805	// function mint(address to, uint256 tokenId) public returns (bool) {806	// 	require(false, stub_error);807	// 	to;808	// 	tokenId;809	// 	dummy = 0;810	// 	return false;811	// }812813	/// @notice Function to mint token with the given tokenUri.814	/// @param to The new owner815	/// @param tokenUri Token URI that would be stored in the NFT properties816	/// @return uint256 The id of the newly minted token817	/// @dev EVM selector for this function is: 0x45c17782,818	///  or in textual repr: mintWithTokenURI(address,string)819	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {820		require(false, stub_error);821		to;822		tokenUri;823		dummy = 0;824		return 0;825	}826827	// /// @notice Function to mint token with the given tokenUri.828	// /// @dev `tokenId` should be obtained with `nextTokenId` method,829	// ///  unlike standard, you can't specify it manually830	// /// @param to The new owner831	// /// @param tokenId ID of the minted NFT832	// /// @param tokenUri Token URI that would be stored in the NFT properties833	// /// @dev EVM selector for this function is: 0x50bb4e7f,834	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)835	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {836	// 	require(false, stub_error);837	// 	to;838	// 	tokenId;839	// 	tokenUri;840	// 	dummy = 0;841	// 	return false;842	// }843844	/// @dev Not implemented845	/// @dev EVM selector for this function is: 0x7d64bcb4,846	///  or in textual repr: finishMinting()847	function finishMinting() public returns (bool) {848		require(false, stub_error);849		dummy = 0;850		return false;851	}852}853854/// @title Unique extensions for ERC721.855/// @dev the ERC-165 identifier for this interface is 0x0e48fdb4856contract ERC721UniqueExtensions is Dummy, ERC165 {857	/// @notice A descriptive name for a collection of NFTs in this contract858	/// @dev EVM selector for this function is: 0x06fdde03,859	///  or in textual repr: name()860	function name() public view returns (string memory) {861		require(false, stub_error);862		dummy;863		return "";864	}865866	/// @notice An abbreviated name for NFTs in this contract867	/// @dev EVM selector for this function is: 0x95d89b41,868	///  or in textual repr: symbol()869	function symbol() public view returns (string memory) {870		require(false, stub_error);871		dummy;872		return "";873	}874875	/// @notice A description for the collection.876	/// @dev EVM selector for this function is: 0x7284e416,877	///  or in textual repr: description()878	function description() public view returns (string memory) {879		require(false, stub_error);880		dummy;881		return "";882	}883884	/// Returns the owner (in cross format) of the token.885	///886	/// @param tokenId Id for the token.887	/// @dev EVM selector for this function is: 0x2b29dace,888	///  or in textual repr: crossOwnerOf(uint256)889	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {890		require(false, stub_error);891		tokenId;892		dummy;893		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);894	}895896	/// Returns the token properties.897	///898	/// @param tokenId Id for the token.899	/// @param keys Properties keys. Empty keys for all propertyes.900	/// @return Vector of properties key/value pairs.901	/// @dev EVM selector for this function is: 0xe07ede7e,902	///  or in textual repr: properties(uint256,string[])903	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {904		require(false, stub_error);905		tokenId;906		keys;907		dummy;908		return new Property[](0);909	}910911	/// @notice Set or reaffirm the approved address for an NFT912	/// @dev The zero address indicates there is no approved address.913	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized914	///  operator of the current owner.915	/// @param approved The new substrate address approved NFT controller916	/// @param tokenId The NFT to approve917	/// @dev EVM selector for this function is: 0x0ecd0ab0,918	///  or in textual repr: approveCross((address,uint256),uint256)919	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {920		require(false, stub_error);921		approved;922		tokenId;923		dummy = 0;924	}925926	/// @notice Transfer ownership of an NFT927	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`928	///  is the zero address. Throws if `tokenId` is not a valid NFT.929	/// @param to The new owner930	/// @param tokenId The NFT to transfer931	/// @dev EVM selector for this function is: 0xa9059cbb,932	///  or in textual repr: transfer(address,uint256)933	function transfer(address to, uint256 tokenId) public {934		require(false, stub_error);935		to;936		tokenId;937		dummy = 0;938	}939940	/// @notice Transfer ownership of an NFT941	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`942	///  is the zero address. Throws if `tokenId` is not a valid NFT.943	/// @param to The new owner944	/// @param tokenId The NFT to transfer945	/// @dev EVM selector for this function is: 0x2ada85ff,946	///  or in textual repr: transferCross((address,uint256),uint256)947	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {948		require(false, stub_error);949		to;950		tokenId;951		dummy = 0;952	}953954	/// @notice Transfer ownership of an NFT from cross account address to cross account address955	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`956	///  is the zero address. Throws if `tokenId` is not a valid NFT.957	/// @param from Cross acccount address of current owner958	/// @param to Cross acccount address of new owner959	/// @param tokenId The NFT to transfer960	/// @dev EVM selector for this function is: 0xd5cf430b,961	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)962	function transferFromCross(963		EthCrossAccount memory from,964		EthCrossAccount memory to,965		uint256 tokenId966	) public {967		require(false, stub_error);968		from;969		to;970		tokenId;971		dummy = 0;972	}973974	// /// @notice Burns a specific ERC721 token.975	// /// @dev Throws unless `msg.sender` is the current owner or an authorized976	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws977	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.978	// /// @param from The current owner of the NFT979	// /// @param tokenId The NFT to transfer980	// /// @dev EVM selector for this function is: 0x79cc6790,981	// ///  or in textual repr: burnFrom(address,uint256)982	// function burnFrom(address from, uint256 tokenId) public {983	// 	require(false, stub_error);984	// 	from;985	// 	tokenId;986	// 	dummy = 0;987	// }988989	/// @notice Burns a specific ERC721 token.990	/// @dev Throws unless `msg.sender` is the current owner or an authorized991	///  operator for this NFT. Throws if `from` is not the current owner. Throws992	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.993	/// @param from The current owner of the NFT994	/// @param tokenId The NFT to transfer995	/// @dev EVM selector for this function is: 0xbb2f5a58,996	///  or in textual repr: burnFromCross((address,uint256),uint256)997	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {998		require(false, stub_error);999		from;1000		tokenId;1001		dummy = 0;1002	}10031004	/// @notice Returns next free NFT ID.1005	/// @dev EVM selector for this function is: 0x75794a3c,1006	///  or in textual repr: nextTokenId()1007	function nextTokenId() public view returns (uint256) {1008		require(false, stub_error);1009		dummy;1010		return 0;1011	}10121013	// /// @notice Function to mint multiple tokens.1014	// /// @dev `tokenIds` should be an array of consecutive numbers and first number1015	// ///  should be obtained with `nextTokenId` method1016	// /// @param to The new owner1017	// /// @param tokenIds IDs of the minted NFTs1018	// /// @dev EVM selector for this function is: 0x44a9945e,1019	// ///  or in textual repr: mintBulk(address,uint256[])1020	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {1021	// 	require(false, stub_error);1022	// 	to;1023	// 	tokenIds;1024	// 	dummy = 0;1025	// 	return false;1026	// }10271028	// /// @notice Function to mint multiple tokens with the given tokenUris.1029	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1030	// ///  numbers and first number should be obtained with `nextTokenId` method1031	// /// @param to The new owner1032	// /// @param tokens array of pairs of token ID and token URI for minted tokens1033	// /// @dev EVM selector for this function is: 0x36543006,1034	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])1035	// function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {1036	// 	require(false, stub_error);1037	// 	to;1038	// 	tokens;1039	// 	dummy = 0;1040	// 	return false;1041	// }10421043	/// @notice Function to a mint token.1044	/// @param to The new owner crossAccountId1045	/// @param properties Properties of minted token1046	/// @return uint256 The id of the newly minted token1047	/// @dev EVM selector for this function is: 0xb904db03,1048	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])1049	function mintCross(EthCrossAccount memory to, Property[] memory properties) public returns (uint256) {1050		require(false, stub_error);1051		to;1052		properties;1053		dummy = 0;1054		return 0;1055	}1056}10571058/// @dev anonymous struct1059struct Tuple15 {1060	uint256 field_0;1061	string field_1;1062}10631064/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1065/// @dev See https://eips.ethereum.org/EIPS/eip-7211066/// @dev the ERC-165 identifier for this interface is 0x780e9d631067contract ERC721Enumerable is Dummy, ERC165 {1068	/// @notice Enumerate valid NFTs1069	/// @param index A counter less than `totalSupply()`1070	/// @return The token identifier for the `index`th NFT,1071	///  (sort order not specified)1072	/// @dev EVM selector for this function is: 0x4f6ccce7,1073	///  or in textual repr: tokenByIndex(uint256)1074	function tokenByIndex(uint256 index) public view returns (uint256) {1075		require(false, stub_error);1076		index;1077		dummy;1078		return 0;1079	}10801081	/// @dev Not implemented1082	/// @dev EVM selector for this function is: 0x2f745c59,1083	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1084	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1085		require(false, stub_error);1086		owner;1087		index;1088		dummy;1089		return 0;1090	}10911092	/// @notice Count NFTs tracked by this contract1093	/// @return A count of valid NFTs tracked by this contract, where each one of1094	///  them has an assigned and queryable owner not equal to the zero address1095	/// @dev EVM selector for this function is: 0x18160ddd,1096	///  or in textual repr: totalSupply()1097	function totalSupply() public view returns (uint256) {1098		require(false, stub_error);1099		dummy;1100		return 0;1101	}1102}11031104/// @dev inlined interface1105contract ERC721Events {1106	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1107	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1108	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1109}11101111/// @title ERC-721 Non-Fungible Token Standard1112/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1113/// @dev the ERC-165 identifier for this interface is 0x983a942b1114contract ERC721 is Dummy, ERC165, ERC721Events {1115	/// @notice Count all NFTs assigned to an owner1116	/// @dev NFTs assigned to the zero address are considered invalid, and this1117	///  function throws for queries about the zero address.1118	/// @param owner An address for whom to query the balance1119	/// @return The number of NFTs owned by `owner`, possibly zero1120	/// @dev EVM selector for this function is: 0x70a08231,1121	///  or in textual repr: balanceOf(address)1122	function balanceOf(address owner) public view returns (uint256) {1123		require(false, stub_error);1124		owner;1125		dummy;1126		return 0;1127	}11281129	/// @notice Find the owner of an NFT1130	/// @dev NFTs assigned to zero address are considered invalid, and queries1131	///  about them do throw.1132	/// @param tokenId The identifier for an NFT1133	/// @return The address of the owner of the NFT1134	/// @dev EVM selector for this function is: 0x6352211e,1135	///  or in textual repr: ownerOf(uint256)1136	function ownerOf(uint256 tokenId) public view returns (address) {1137		require(false, stub_error);1138		tokenId;1139		dummy;1140		return 0x0000000000000000000000000000000000000000;1141	}11421143	/// @dev Not implemented1144	/// @dev EVM selector for this function is: 0xb88d4fde,1145	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)1146	function safeTransferFrom(1147		address from,1148		address to,1149		uint256 tokenId,1150		bytes memory data1151	) public {1152		require(false, stub_error);1153		from;1154		to;1155		tokenId;1156		data;1157		dummy = 0;1158	}11591160	/// @dev Not implemented1161	/// @dev EVM selector for this function is: 0x42842e0e,1162	///  or in textual repr: safeTransferFrom(address,address,uint256)1163	function safeTransferFrom(1164		address from,1165		address to,1166		uint256 tokenId1167	) public {1168		require(false, stub_error);1169		from;1170		to;1171		tokenId;1172		dummy = 0;1173	}11741175	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1176	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1177	///  THEY MAY BE PERMANENTLY LOST1178	/// @dev Throws unless `msg.sender` is the current owner or an authorized1179	///  operator for this NFT. Throws if `from` is not the current owner. Throws1180	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.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	/// @notice Set or reaffirm the approved address for an NFT1199	/// @dev The zero address indicates there is no approved address.1200	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1201	///  operator of the current owner.1202	/// @param approved The new approved NFT controller1203	/// @param tokenId The NFT to approve1204	/// @dev EVM selector for this function is: 0x095ea7b3,1205	///  or in textual repr: approve(address,uint256)1206	function approve(address approved, uint256 tokenId) public {1207		require(false, stub_error);1208		approved;1209		tokenId;1210		dummy = 0;1211	}12121213	/// @notice Sets or unsets the approval of a given operator.1214	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1215	/// @param operator Operator1216	/// @param approved Should operator status be granted or revoked?1217	/// @dev EVM selector for this function is: 0xa22cb465,1218	///  or in textual repr: setApprovalForAll(address,bool)1219	function setApprovalForAll(address operator, bool approved) public {1220		require(false, stub_error);1221		operator;1222		approved;1223		dummy = 0;1224	}12251226	/// @dev Not implemented1227	/// @dev EVM selector for this function is: 0x081812fc,1228	///  or in textual repr: getApproved(uint256)1229	function getApproved(uint256 tokenId) public view returns (address) {1230		require(false, stub_error);1231		tokenId;1232		dummy;1233		return 0x0000000000000000000000000000000000000000;1234	}12351236	/// @notice Tells whether the given `owner` approves the `operator`.1237	/// @dev EVM selector for this function is: 0xe985e9c5,1238	///  or in textual repr: isApprovedForAll(address,address)1239	function isApprovedForAll(address owner, address operator) public view returns (bool) {1240		require(false, stub_error);1241		owner;1242		operator;1243		dummy;1244		return false;1245	}12461247	/// @notice Returns collection helper contract address1248	/// @dev EVM selector for this function is: 0x1896cce6,1249	///  or in textual repr: collectionHelperAddress()1250	function collectionHelperAddress() public view returns (address) {1251		require(false, stub_error);1252		dummy;1253		return 0x0000000000000000000000000000000000000000;1254	}1255}12561257contract UniqueNFT is1258	Dummy,1259	ERC165,1260	ERC721,1261	ERC721Enumerable,1262	ERC721UniqueExtensions,1263	ERC721UniqueMintable,1264	ERC721Burnable,1265	ERC721Metadata,1266	Collection,1267	TokenProperties1268{}