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

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/// @dev inlined interface21contract ERC721TokenEvent {22	event TokenChanged(uint256 indexed tokenId);23}2425/// @title A contract that allows to set and delete token properties and change token property permissions.26/// @dev the ERC-165 identifier for this interface is 0xde0695c227contract TokenProperties is Dummy, ERC165, ERC721TokenEvent {28	// /// @notice Set permissions for token property.29	// /// @dev Throws error if `msg.sender` is not admin or owner of the collection.30	// /// @param key Property key.31	// /// @param isMutable Permission to mutate property.32	// /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.33	// /// @param tokenOwner Permission to mutate property by token owner if property is mutable.34	// /// @dev EVM selector for this function is: 0x222d97fa,35	// ///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)36	// function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {37	// 	require(false, stub_error);38	// 	key;39	// 	isMutable;40	// 	collectionAdmin;41	// 	tokenOwner;42	// 	dummy = 0;43	// }4445	/// @notice Set permissions for token property.46	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.47	/// @param permissions Permissions for keys.48	/// @dev EVM selector for this function is: 0xbd92983a,49	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])50	function setTokenPropertyPermissions(TokenPropertyPermission[] memory permissions) public {51		require(false, stub_error);52		permissions;53		dummy = 0;54	}5556	/// @notice Get permissions for token properties.57	/// @dev EVM selector for this function is: 0xf23d7790,58	///  or in textual repr: tokenPropertyPermissions()59	function tokenPropertyPermissions() public view returns (TokenPropertyPermission[] memory) {60		require(false, stub_error);61		dummy;62		return new TokenPropertyPermission[](0);63	}6465	// /// @notice Set token property value.66	// /// @dev Throws error if `msg.sender` has no permission to edit the property.67	// /// @param tokenId ID of the token.68	// /// @param key Property key.69	// /// @param value Property value.70	// /// @dev EVM selector for this function is: 0x1752d67b,71	// ///  or in textual repr: setProperty(uint256,string,bytes)72	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {73	// 	require(false, stub_error);74	// 	tokenId;75	// 	key;76	// 	value;77	// 	dummy = 0;78	// }7980	/// @notice Set token properties value.81	/// @dev Throws error if `msg.sender` has no permission to edit the property.82	/// @param tokenId ID of the token.83	/// @param properties settable properties84	/// @dev EVM selector for this function is: 0x14ed3a6e,85	///  or in textual repr: setProperties(uint256,(string,bytes)[])86	function setProperties(uint256 tokenId, Property[] memory properties) public {87		require(false, stub_error);88		tokenId;89		properties;90		dummy = 0;91	}9293	// /// @notice Delete token property value.94	// /// @dev Throws error if `msg.sender` has no permission to edit the property.95	// /// @param tokenId ID of the token.96	// /// @param key Property key.97	// /// @dev EVM selector for this function is: 0x066111d1,98	// ///  or in textual repr: deleteProperty(uint256,string)99	// function deleteProperty(uint256 tokenId, string memory key) public {100	// 	require(false, stub_error);101	// 	tokenId;102	// 	key;103	// 	dummy = 0;104	// }105106	/// @notice Delete token properties value.107	/// @dev Throws error if `msg.sender` has no permission to edit the property.108	/// @param tokenId ID of the token.109	/// @param keys Properties key.110	/// @dev EVM selector for this function is: 0xc472d371,111	///  or in textual repr: deleteProperties(uint256,string[])112	function deleteProperties(uint256 tokenId, string[] memory keys) public {113		require(false, stub_error);114		tokenId;115		keys;116		dummy = 0;117	}118119	/// @notice Get token property value.120	/// @dev Throws error if key not found121	/// @param tokenId ID of the token.122	/// @param key Property key.123	/// @return Property value bytes124	/// @dev EVM selector for this function is: 0x7228c327,125	///  or in textual repr: property(uint256,string)126	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {127		require(false, stub_error);128		tokenId;129		key;130		dummy;131		return hex"";132	}133}134135/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).136struct Property {137	string key;138	bytes value;139}140141/// Ethereum representation of Token Property Permissions.142struct TokenPropertyPermission {143	/// Token property key.144	string key;145	/// Token property permissions.146	PropertyPermission[] permissions;147}148149/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.150struct PropertyPermission {151	/// TokenPermission field.152	TokenPermissionField code;153	/// TokenPermission value.154	bool value;155}156157/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.158enum TokenPermissionField {159	/// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]160	Mutable,161	/// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]162	TokenOwner,163	/// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]164	CollectionAdmin165}166167/// @title A contract that allows you to work with collections.168/// @dev the ERC-165 identifier for this interface is 0x2a14cfd1169contract Collection is Dummy, ERC165 {170	// /// Set collection property.171	// ///172	// /// @param key Property key.173	// /// @param value Propery value.174	// /// @dev EVM selector for this function is: 0x2f073f66,175	// ///  or in textual repr: setCollectionProperty(string,bytes)176	// function setCollectionProperty(string memory key, bytes memory value) public {177	// 	require(false, stub_error);178	// 	key;179	// 	value;180	// 	dummy = 0;181	// }182183	/// Set collection properties.184	///185	/// @param properties Vector of properties key/value pair.186	/// @dev EVM selector for this function is: 0x50b26b2a,187	///  or in textual repr: setCollectionProperties((string,bytes)[])188	function setCollectionProperties(Property[] memory properties) public {189		require(false, stub_error);190		properties;191		dummy = 0;192	}193194	// /// Delete collection property.195	// ///196	// /// @param key Property key.197	// /// @dev EVM selector for this function is: 0x7b7debce,198	// ///  or in textual repr: deleteCollectionProperty(string)199	// function deleteCollectionProperty(string memory key) public {200	// 	require(false, stub_error);201	// 	key;202	// 	dummy = 0;203	// }204205	/// Delete collection properties.206	///207	/// @param keys Properties keys.208	/// @dev EVM selector for this function is: 0xee206ee3,209	///  or in textual repr: deleteCollectionProperties(string[])210	function deleteCollectionProperties(string[] memory keys) public {211		require(false, stub_error);212		keys;213		dummy = 0;214	}215216	/// Get collection property.217	///218	/// @dev Throws error if key not found.219	///220	/// @param key Property key.221	/// @return bytes The property corresponding to the key.222	/// @dev EVM selector for this function is: 0xcf24fd6d,223	///  or in textual repr: collectionProperty(string)224	function collectionProperty(string memory key) public view returns (bytes memory) {225		require(false, stub_error);226		key;227		dummy;228		return hex"";229	}230231	/// Get collection properties.232	///233	/// @param keys Properties keys. Empty keys for all propertyes.234	/// @return Vector of properties key/value pairs.235	/// @dev EVM selector for this function is: 0x285fb8e6,236	///  or in textual repr: collectionProperties(string[])237	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {238		require(false, stub_error);239		keys;240		dummy;241		return new Property[](0);242	}243244	// /// Set the sponsor of the collection.245	// ///246	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.247	// ///248	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.249	// /// @dev EVM selector for this function is: 0x7623402e,250	// ///  or in textual repr: setCollectionSponsor(address)251	// function setCollectionSponsor(address sponsor) public {252	// 	require(false, stub_error);253	// 	sponsor;254	// 	dummy = 0;255	// }256257	/// Set the sponsor of the collection.258	///259	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.260	///261	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.262	/// @dev EVM selector for this function is: 0x84a1d5a8,263	///  or in textual repr: setCollectionSponsorCross((address,uint256))264	function setCollectionSponsorCross(CrossAddress memory sponsor) public {265		require(false, stub_error);266		sponsor;267		dummy = 0;268	}269270	/// Whether there is a pending sponsor.271	/// @dev EVM selector for this function is: 0x058ac185,272	///  or in textual repr: hasCollectionPendingSponsor()273	function hasCollectionPendingSponsor() public view returns (bool) {274		require(false, stub_error);275		dummy;276		return false;277	}278279	/// Collection sponsorship confirmation.280	///281	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.282	/// @dev EVM selector for this function is: 0x3c50e97a,283	///  or in textual repr: confirmCollectionSponsorship()284	function confirmCollectionSponsorship() public {285		require(false, stub_error);286		dummy = 0;287	}288289	/// Remove collection sponsor.290	/// @dev EVM selector for this function is: 0x6e0326a3,291	///  or in textual repr: removeCollectionSponsor()292	function removeCollectionSponsor() public {293		require(false, stub_error);294		dummy = 0;295	}296297	/// Get current sponsor.298	///299	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.300	/// @dev EVM selector for this function is: 0x6ec0a9f1,301	///  or in textual repr: collectionSponsor()302	function collectionSponsor() public view returns (CrossAddress memory) {303		require(false, stub_error);304		dummy;305		return CrossAddress(0x0000000000000000000000000000000000000000, 0);306	}307308	/// Get current collection limits.309	///310	/// @return Array of collection limits311	/// @dev EVM selector for this function is: 0xf63bc572,312	///  or in textual repr: collectionLimits()313	function collectionLimits() public view returns (CollectionLimit[] memory) {314		require(false, stub_error);315		dummy;316		return new CollectionLimit[](0);317	}318319	/// Set limits for the collection.320	/// @dev Throws error if limit not found.321	/// @param limit Some limit.322	/// @dev EVM selector for this function is: 0x2316ee74,323	///  or in textual repr: setCollectionLimit((uint8,(bool,uint256)))324	function setCollectionLimit(CollectionLimit memory limit) public {325		require(false, stub_error);326		limit;327		dummy = 0;328	}329330	/// Get contract address.331	/// @dev EVM selector for this function is: 0xf6b4dfb4,332	///  or in textual repr: contractAddress()333	function contractAddress() public view returns (address) {334		require(false, stub_error);335		dummy;336		return 0x0000000000000000000000000000000000000000;337	}338339	/// Add collection admin.340	/// @param newAdmin Cross account administrator address.341	/// @dev EVM selector for this function is: 0x859aa7d6,342	///  or in textual repr: addCollectionAdminCross((address,uint256))343	function addCollectionAdminCross(CrossAddress memory newAdmin) public {344		require(false, stub_error);345		newAdmin;346		dummy = 0;347	}348349	/// Remove collection admin.350	/// @param admin Cross account administrator address.351	/// @dev EVM selector for this function is: 0x6c0cd173,352	///  or in textual repr: removeCollectionAdminCross((address,uint256))353	function removeCollectionAdminCross(CrossAddress memory admin) public {354		require(false, stub_error);355		admin;356		dummy = 0;357	}358359	// /// Add collection admin.360	// /// @param newAdmin Address of the added administrator.361	// /// @dev EVM selector for this function is: 0x92e462c7,362	// ///  or in textual repr: addCollectionAdmin(address)363	// function addCollectionAdmin(address newAdmin) public {364	// 	require(false, stub_error);365	// 	newAdmin;366	// 	dummy = 0;367	// }368369	// /// Remove collection admin.370	// ///371	// /// @param admin Address of the removed administrator.372	// /// @dev EVM selector for this function is: 0xfafd7b42,373	// ///  or in textual repr: removeCollectionAdmin(address)374	// function removeCollectionAdmin(address admin) public {375	// 	require(false, stub_error);376	// 	admin;377	// 	dummy = 0;378	// }379380	/// Toggle accessibility of collection nesting.381	///382	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'383	/// @dev EVM selector for this function is: 0x112d4586,384	///  or in textual repr: setCollectionNesting(bool)385	function setCollectionNesting(bool enable) public {386		require(false, stub_error);387		enable;388		dummy = 0;389	}390391	/// Toggle accessibility of collection nesting.392	///393	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'394	/// @param collections Addresses of collections that will be available for nesting.395	/// @dev EVM selector for this function is: 0x64872396,396	///  or in textual repr: setCollectionNesting(bool,address[])397	function setCollectionNesting(bool enable, address[] memory collections) public {398		require(false, stub_error);399		enable;400		collections;401		dummy = 0;402	}403404	/// Returns nesting for a collection405	/// @dev EVM selector for this function is: 0x22d25bfe,406	///  or in textual repr: collectionNestingRestrictedCollectionIds()407	function collectionNestingRestrictedCollectionIds() public view returns (CollectionNesting memory) {408		require(false, stub_error);409		dummy;410		return CollectionNesting(false, new uint256[](0));411	}412413	/// Returns permissions for a collection414	/// @dev EVM selector for this function is: 0x5b2eaf4b,415	///  or in textual repr: collectionNestingPermissions()416	function collectionNestingPermissions() public view returns (CollectionNestingPermission[] memory) {417		require(false, stub_error);418		dummy;419		return new CollectionNestingPermission[](0);420	}421422	/// Set the collection access method.423	/// @param mode Access mode424	/// @dev EVM selector for this function is: 0x41835d4c,425	///  or in textual repr: setCollectionAccess(uint8)426	function setCollectionAccess(AccessMode mode) public {427		require(false, stub_error);428		mode;429		dummy = 0;430	}431432	/// Checks that user allowed to operate with collection.433	///434	/// @param user User address to check.435	/// @dev EVM selector for this function is: 0x91b6df49,436	///  or in textual repr: allowlistedCross((address,uint256))437	function allowlistedCross(CrossAddress memory user) public view returns (bool) {438		require(false, stub_error);439		user;440		dummy;441		return false;442	}443444	// /// Add the user to the allowed list.445	// ///446	// /// @param user Address of a trusted user.447	// /// @dev EVM selector for this function is: 0x67844fe6,448	// ///  or in textual repr: addToCollectionAllowList(address)449	// function addToCollectionAllowList(address user) public {450	// 	require(false, stub_error);451	// 	user;452	// 	dummy = 0;453	// }454455	/// Add user to allowed list.456	///457	/// @param user User cross account address.458	/// @dev EVM selector for this function is: 0xa0184a3a,459	///  or in textual repr: addToCollectionAllowListCross((address,uint256))460	function addToCollectionAllowListCross(CrossAddress memory user) public {461		require(false, stub_error);462		user;463		dummy = 0;464	}465466	// /// Remove the user from the allowed list.467	// ///468	// /// @param user Address of a removed user.469	// /// @dev EVM selector for this function is: 0x85c51acb,470	// ///  or in textual repr: removeFromCollectionAllowList(address)471	// function removeFromCollectionAllowList(address user) public {472	// 	require(false, stub_error);473	// 	user;474	// 	dummy = 0;475	// }476477	/// Remove user from allowed list.478	///479	/// @param user User cross account address.480	/// @dev EVM selector for this function is: 0x09ba452a,481	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))482	function removeFromCollectionAllowListCross(CrossAddress memory user) public {483		require(false, stub_error);484		user;485		dummy = 0;486	}487488	/// Switch permission for minting.489	///490	/// @param mode Enable if "true".491	/// @dev EVM selector for this function is: 0x00018e84,492	///  or in textual repr: setCollectionMintMode(bool)493	function setCollectionMintMode(bool mode) public {494		require(false, stub_error);495		mode;496		dummy = 0;497	}498499	// /// Check that account is the owner or admin of the collection500	// ///501	// /// @param user account to verify502	// /// @return "true" if account is the owner or admin503	// /// @dev EVM selector for this function is: 0x9811b0c7,504	// ///  or in textual repr: isOwnerOrAdmin(address)505	// function isOwnerOrAdmin(address user) public view returns (bool) {506	// 	require(false, stub_error);507	// 	user;508	// 	dummy;509	// 	return false;510	// }511512	/// Check that account is the owner or admin of the collection513	///514	/// @param user User cross account to verify515	/// @return "true" if account is the owner or admin516	/// @dev EVM selector for this function is: 0x3e75a905,517	///  or in textual repr: isOwnerOrAdminCross((address,uint256))518	function isOwnerOrAdminCross(CrossAddress memory user) public view returns (bool) {519		require(false, stub_error);520		user;521		dummy;522		return false;523	}524525	/// Returns collection type526	///527	/// @return `Fungible` or `NFT` or `ReFungible`528	/// @dev EVM selector for this function is: 0xd34b55b8,529	///  or in textual repr: uniqueCollectionType()530	function uniqueCollectionType() public view returns (string memory) {531		require(false, stub_error);532		dummy;533		return "";534	}535536	/// Get collection owner.537	///538	/// @return Tuble with sponsor address and his substrate mirror.539	/// If address is canonical then substrate mirror is zero and vice versa.540	/// @dev EVM selector for this function is: 0xdf727d3b,541	///  or in textual repr: collectionOwner()542	function collectionOwner() public view returns (CrossAddress memory) {543		require(false, stub_error);544		dummy;545		return CrossAddress(0x0000000000000000000000000000000000000000, 0);546	}547548	// /// Changes collection owner to another account549	// ///550	// /// @dev Owner can be changed only by current owner551	// /// @param newOwner new owner account552	// /// @dev EVM selector for this function is: 0x4f53e226,553	// ///  or in textual repr: changeCollectionOwner(address)554	// function changeCollectionOwner(address newOwner) public {555	// 	require(false, stub_error);556	// 	newOwner;557	// 	dummy = 0;558	// }559560	/// Get collection administrators561	///562	/// @return Vector of tuples with admins address and his substrate mirror.563	/// If address is canonical then substrate mirror is zero and vice versa.564	/// @dev EVM selector for this function is: 0x5813216b,565	///  or in textual repr: collectionAdmins()566	function collectionAdmins() public view returns (CrossAddress[] memory) {567		require(false, stub_error);568		dummy;569		return new CrossAddress[](0);570	}571572	/// Changes collection owner to another account573	///574	/// @dev Owner can be changed only by current owner575	/// @param newOwner new owner cross account576	/// @dev EVM selector for this function is: 0x6496c497,577	///  or in textual repr: changeCollectionOwnerCross((address,uint256))578	function changeCollectionOwnerCross(CrossAddress memory newOwner) public {579		require(false, stub_error);580		newOwner;581		dummy = 0;582	}583}584585/// Cross account struct586struct CrossAddress {587	address eth;588	uint256 sub;589}590591/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).592enum AccessMode {593	/// Access grant for owner and admins. Used as default.594	Normal,595	/// Like a [`Normal`](AccessMode::Normal) but also users in allow list.596	AllowList597}598599/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.600struct CollectionNestingPermission {601	CollectionPermissionField field;602	bool value;603}604605/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.606enum CollectionPermissionField {607	/// Owner of token can nest tokens under it.608	TokenOwner,609	/// Admin of token collection can nest tokens under token.610	CollectionAdmin611}612613/// Nested collections.614struct CollectionNesting {615	bool token_owner;616	uint256[] ids;617}618619/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.620struct CollectionLimit {621	CollectionLimitField field;622	OptionUint256 value;623}624625/// Optional value626struct OptionUint256 {627	/// Shows the status of accessibility of value628	bool status;629	/// Actual value if `status` is true630	uint256 value;631}632633/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.634enum CollectionLimitField {635	/// How many tokens can a user have on one account.636	AccountTokenOwnership,637	/// How many bytes of data are available for sponsorship.638	SponsoredDataSize,639	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]640	SponsoredDataRateLimit,641	/// How many tokens can be mined into this collection.642	TokenLimit,643	/// Timeouts for transfer sponsoring.644	SponsorTransferTimeout,645	/// Timeout for sponsoring an approval in passed blocks.646	SponsorApproveTimeout,647	/// Whether the collection owner of the collection can send tokens (which belong to other users).648	OwnerCanTransfer,649	/// Can the collection owner burn other people's tokens.650	OwnerCanDestroy,651	/// Is it possible to send tokens from this collection between users.652	TransferEnabled653}654655/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension656/// @dev See https://eips.ethereum.org/EIPS/eip-721657/// @dev the ERC-165 identifier for this interface is 0x5b5e139f658contract ERC721Metadata is Dummy, ERC165 {659	// /// @notice A descriptive name for a collection of NFTs in this contract660	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`661	// /// @dev EVM selector for this function is: 0x06fdde03,662	// ///  or in textual repr: name()663	// function name() public view returns (string memory) {664	// 	require(false, stub_error);665	// 	dummy;666	// 	return "";667	// }668669	// /// @notice An abbreviated name for NFTs in this contract670	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`671	// /// @dev EVM selector for this function is: 0x95d89b41,672	// ///  or in textual repr: symbol()673	// function symbol() public view returns (string memory) {674	// 	require(false, stub_error);675	// 	dummy;676	// 	return "";677	// }678679	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.680	///681	/// @dev If the token has a `url` property and it is not empty, it is returned.682	///  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`.683	///  If the collection property `baseURI` is empty or absent, return "" (empty string)684	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix685	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).686	///687	/// @return token's const_metadata688	/// @dev EVM selector for this function is: 0xc87b56dd,689	///  or in textual repr: tokenURI(uint256)690	function tokenURI(uint256 tokenId) public view returns (string memory) {691		require(false, stub_error);692		tokenId;693		dummy;694		return "";695	}696}697698/// @title ERC721 Token that can be irreversibly burned (destroyed).699/// @dev the ERC-165 identifier for this interface is 0x42966c68700contract ERC721Burnable is Dummy, ERC165 {701	/// @notice Burns a specific ERC721 token.702	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized703	///  operator of the current owner.704	/// @param tokenId The NFT to approve705	/// @dev EVM selector for this function is: 0x42966c68,706	///  or in textual repr: burn(uint256)707	function burn(uint256 tokenId) public {708		require(false, stub_error);709		tokenId;710		dummy = 0;711	}712}713714/// @title ERC721 minting logic.715/// @dev the ERC-165 identifier for this interface is 0x3fd94ea6716contract ERC721UniqueMintable is Dummy, ERC165 {717	/// @notice Function to mint a token.718	/// @param to The new owner719	/// @return uint256 The id of the newly minted token720	/// @dev EVM selector for this function is: 0x6a627842,721	///  or in textual repr: mint(address)722	function mint(address to) public returns (uint256) {723		require(false, stub_error);724		to;725		dummy = 0;726		return 0;727	}728729	// /// @notice Function to mint a token.730	// /// @dev `tokenId` should be obtained with `nextTokenId` method,731	// ///  unlike standard, you can't specify it manually732	// /// @param to The new owner733	// /// @param tokenId ID of the minted NFT734	// /// @dev EVM selector for this function is: 0x40c10f19,735	// ///  or in textual repr: mint(address,uint256)736	// function mint(address to, uint256 tokenId) public returns (bool) {737	// 	require(false, stub_error);738	// 	to;739	// 	tokenId;740	// 	dummy = 0;741	// 	return false;742	// }743744	/// @notice Function to mint token with the given tokenUri.745	/// @param to The new owner746	/// @param tokenUri Token URI that would be stored in the NFT properties747	/// @return uint256 The id of the newly minted token748	/// @dev EVM selector for this function is: 0x45c17782,749	///  or in textual repr: mintWithTokenURI(address,string)750	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {751		require(false, stub_error);752		to;753		tokenUri;754		dummy = 0;755		return 0;756	}757	// /// @notice Function to mint token with the given tokenUri.758	// /// @dev `tokenId` should be obtained with `nextTokenId` method,759	// ///  unlike standard, you can't specify it manually760	// /// @param to The new owner761	// /// @param tokenId ID of the minted NFT762	// /// @param tokenUri Token URI that would be stored in the NFT properties763	// /// @dev EVM selector for this function is: 0x50bb4e7f,764	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)765	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {766	// 	require(false, stub_error);767	// 	to;768	// 	tokenId;769	// 	tokenUri;770	// 	dummy = 0;771	// 	return false;772	// }773774}775776/// @title Unique extensions for ERC721.777/// @dev the ERC-165 identifier for this interface is 0x323b1db8778contract ERC721UniqueExtensions is Dummy, ERC165 {779	/// @notice A descriptive name for a collection of NFTs in this contract780	/// @dev EVM selector for this function is: 0x06fdde03,781	///  or in textual repr: name()782	function name() public view returns (string memory) {783		require(false, stub_error);784		dummy;785		return "";786	}787788	/// @notice An abbreviated name for NFTs in this contract789	/// @dev EVM selector for this function is: 0x95d89b41,790	///  or in textual repr: symbol()791	function symbol() public view returns (string memory) {792		require(false, stub_error);793		dummy;794		return "";795	}796797	/// @notice A description for the collection.798	/// @dev EVM selector for this function is: 0x7284e416,799	///  or in textual repr: description()800	function description() public view returns (string memory) {801		require(false, stub_error);802		dummy;803		return "";804	}805806	/// Returns the owner (in cross format) of the token.807	///808	/// @param tokenId Id for the token.809	/// @dev EVM selector for this function is: 0x2b29dace,810	///  or in textual repr: crossOwnerOf(uint256)811	function crossOwnerOf(uint256 tokenId) public view returns (CrossAddress memory) {812		require(false, stub_error);813		tokenId;814		dummy;815		return CrossAddress(0x0000000000000000000000000000000000000000, 0);816	}817818	/// @notice Count all NFTs assigned to an owner819	/// @dev NFTs assigned to the zero address are considered invalid, and this820	///  function throws for queries about the zero address.821	/// @param owner An cross address for whom to query the balance822	/// @return The number of NFTs owned by `owner`, possibly zero823	/// @dev EVM selector for this function is: 0x24e52cea,824	///  or in textual repr: crossBalanceOf((address,uint256))825	function crossBalanceOf(CrossAddress memory owner) public view returns (uint256) {826		require(false, stub_error);827		owner;828		dummy;829		return 0;830	}831832	/// Returns the token properties.833	///834	/// @param tokenId Id for the token.835	/// @param keys Properties keys. Empty keys for all propertyes.836	/// @return Vector of properties key/value pairs.837	/// @dev EVM selector for this function is: 0xe07ede7e,838	///  or in textual repr: properties(uint256,string[])839	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {840		require(false, stub_error);841		tokenId;842		keys;843		dummy;844		return new Property[](0);845	}846847	/// @notice Set or reaffirm the approved address for an NFT848	/// @dev The zero address indicates there is no approved address.849	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized850	///  operator of the current owner.851	/// @param approved The new substrate address approved NFT controller852	/// @param tokenId The NFT to approve853	/// @dev EVM selector for this function is: 0x0ecd0ab0,854	///  or in textual repr: approveCross((address,uint256),uint256)855	function approveCross(CrossAddress memory approved, uint256 tokenId) public {856		require(false, stub_error);857		approved;858		tokenId;859		dummy = 0;860	}861862	/// @notice Transfer ownership of an NFT863	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`864	///  is the zero address. Throws if `tokenId` is not a valid NFT.865	/// @param to The new owner866	/// @param tokenId The NFT to transfer867	/// @dev EVM selector for this function is: 0xa9059cbb,868	///  or in textual repr: transfer(address,uint256)869	function transfer(address to, uint256 tokenId) public {870		require(false, stub_error);871		to;872		tokenId;873		dummy = 0;874	}875876	/// @notice Transfer ownership of an NFT877	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`878	///  is the zero address. Throws if `tokenId` is not a valid NFT.879	/// @param to The new owner880	/// @param tokenId The NFT to transfer881	/// @dev EVM selector for this function is: 0x2ada85ff,882	///  or in textual repr: transferCross((address,uint256),uint256)883	function transferCross(CrossAddress memory to, uint256 tokenId) public {884		require(false, stub_error);885		to;886		tokenId;887		dummy = 0;888	}889890	/// @notice Transfer ownership of an NFT from cross account address to cross account address891	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`892	///  is the zero address. Throws if `tokenId` is not a valid NFT.893	/// @param from Cross acccount address of current owner894	/// @param to Cross acccount address of new owner895	/// @param tokenId The NFT to transfer896	/// @dev EVM selector for this function is: 0xd5cf430b,897	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)898	function transferFromCross(899		CrossAddress memory from,900		CrossAddress memory to,901		uint256 tokenId902	) public {903		require(false, stub_error);904		from;905		to;906		tokenId;907		dummy = 0;908	}909910	// /// @notice Burns a specific ERC721 token.911	// /// @dev Throws unless `msg.sender` is the current owner or an authorized912	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws913	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.914	// /// @param from The current owner of the NFT915	// /// @param tokenId The NFT to transfer916	// /// @dev EVM selector for this function is: 0x79cc6790,917	// ///  or in textual repr: burnFrom(address,uint256)918	// function burnFrom(address from, uint256 tokenId) public {919	// 	require(false, stub_error);920	// 	from;921	// 	tokenId;922	// 	dummy = 0;923	// }924925	/// @notice Burns a specific ERC721 token.926	/// @dev Throws unless `msg.sender` is the current owner or an authorized927	///  operator for this NFT. Throws if `from` is not the current owner. Throws928	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.929	/// @param from The current owner of the NFT930	/// @param tokenId The NFT to transfer931	/// @dev EVM selector for this function is: 0xbb2f5a58,932	///  or in textual repr: burnFromCross((address,uint256),uint256)933	function burnFromCross(CrossAddress memory from, uint256 tokenId) public {934		require(false, stub_error);935		from;936		tokenId;937		dummy = 0;938	}939940	/// @notice Returns next free NFT ID.941	/// @dev EVM selector for this function is: 0x75794a3c,942	///  or in textual repr: nextTokenId()943	function nextTokenId() public view returns (uint256) {944		require(false, stub_error);945		dummy;946		return 0;947	}948949	// /// @notice Function to mint multiple tokens.950	// /// @dev `tokenIds` should be an array of consecutive numbers and first number951	// ///  should be obtained with `nextTokenId` method952	// /// @param to The new owner953	// /// @param tokenIds IDs of the minted NFTs954	// /// @dev EVM selector for this function is: 0x44a9945e,955	// ///  or in textual repr: mintBulk(address,uint256[])956	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {957	// 	require(false, stub_error);958	// 	to;959	// 	tokenIds;960	// 	dummy = 0;961	// 	return false;962	// }963964	// /// @notice Function to mint multiple tokens with the given tokenUris.965	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive966	// ///  numbers and first number should be obtained with `nextTokenId` method967	// /// @param to The new owner968	// /// @param tokens array of pairs of token ID and token URI for minted tokens969	// /// @dev EVM selector for this function is: 0x36543006,970	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])971	// function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) public returns (bool) {972	// 	require(false, stub_error);973	// 	to;974	// 	tokens;975	// 	dummy = 0;976	// 	return false;977	// }978979	/// @notice Function to mint a token.980	/// @param to The new owner crossAccountId981	/// @param properties Properties of minted token982	/// @return uint256 The id of the newly minted token983	/// @dev EVM selector for this function is: 0xb904db03,984	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])985	function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {986		require(false, stub_error);987		to;988		properties;989		dummy = 0;990		return 0;991	}992993	/// @notice Returns collection helper contract address994	/// @dev EVM selector for this function is: 0x1896cce6,995	///  or in textual repr: collectionHelperAddress()996	function collectionHelperAddress() public view returns (address) {997		require(false, stub_error);998		dummy;999		return 0x0000000000000000000000000000000000000000;1000	}1001}10021003/// Data for creation token with uri.1004struct TokenUri {1005	/// Id of new token.1006	uint256 id;1007	/// Uri of new token.1008	string uri;1009}10101011/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1012/// @dev See https://eips.ethereum.org/EIPS/eip-7211013/// @dev the ERC-165 identifier for this interface is 0x780e9d631014contract ERC721Enumerable is Dummy, ERC165 {1015	/// @notice Enumerate valid NFTs1016	/// @param index A counter less than `totalSupply()`1017	/// @return The token identifier for the `index`th NFT,1018	///  (sort order not specified)1019	/// @dev EVM selector for this function is: 0x4f6ccce7,1020	///  or in textual repr: tokenByIndex(uint256)1021	function tokenByIndex(uint256 index) public view returns (uint256) {1022		require(false, stub_error);1023		index;1024		dummy;1025		return 0;1026	}10271028	/// @dev Not implemented1029	/// @dev EVM selector for this function is: 0x2f745c59,1030	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1031	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1032		require(false, stub_error);1033		owner;1034		index;1035		dummy;1036		return 0;1037	}10381039	/// @notice Count NFTs tracked by this contract1040	/// @return A count of valid NFTs tracked by this contract, where each one of1041	///  them has an assigned and queryable owner not equal to the zero address1042	/// @dev EVM selector for this function is: 0x18160ddd,1043	///  or in textual repr: totalSupply()1044	function totalSupply() public view returns (uint256) {1045		require(false, stub_error);1046		dummy;1047		return 0;1048	}1049}10501051/// @dev inlined interface1052contract ERC721Events {1053	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1054	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1055	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1056}10571058/// @title ERC-721 Non-Fungible Token Standard1059/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1060/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1061contract ERC721 is Dummy, ERC165, ERC721Events {1062	/// @notice Count all NFTs assigned to an owner1063	/// @dev NFTs assigned to the zero address are considered invalid, and this1064	///  function throws for queries about the zero address.1065	/// @param owner An address for whom to query the balance1066	/// @return The number of NFTs owned by `owner`, possibly zero1067	/// @dev EVM selector for this function is: 0x70a08231,1068	///  or in textual repr: balanceOf(address)1069	function balanceOf(address owner) public view returns (uint256) {1070		require(false, stub_error);1071		owner;1072		dummy;1073		return 0;1074	}10751076	/// @notice Find the owner of an NFT1077	/// @dev NFTs assigned to zero address are considered invalid, and queries1078	///  about them do throw.1079	/// @param tokenId The identifier for an NFT1080	/// @return The address of the owner of the NFT1081	/// @dev EVM selector for this function is: 0x6352211e,1082	///  or in textual repr: ownerOf(uint256)1083	function ownerOf(uint256 tokenId) public view returns (address) {1084		require(false, stub_error);1085		tokenId;1086		dummy;1087		return 0x0000000000000000000000000000000000000000;1088	}10891090	/// @dev Not implemented1091	/// @dev EVM selector for this function is: 0xb88d4fde,1092	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)1093	function safeTransferFrom(1094		address from,1095		address to,1096		uint256 tokenId,1097		bytes memory data1098	) public {1099		require(false, stub_error);1100		from;1101		to;1102		tokenId;1103		data;1104		dummy = 0;1105	}11061107	/// @dev Not implemented1108	/// @dev EVM selector for this function is: 0x42842e0e,1109	///  or in textual repr: safeTransferFrom(address,address,uint256)1110	function safeTransferFrom(1111		address from,1112		address to,1113		uint256 tokenId1114	) public {1115		require(false, stub_error);1116		from;1117		to;1118		tokenId;1119		dummy = 0;1120	}11211122	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1123	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1124	///  THEY MAY BE PERMANENTLY LOST1125	/// @dev Throws unless `msg.sender` is the current owner or an authorized1126	///  operator for this NFT. Throws if `from` is not the current owner. Throws1127	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1128	/// @param from The current owner of the NFT1129	/// @param to The new owner1130	/// @param tokenId The NFT to transfer1131	/// @dev EVM selector for this function is: 0x23b872dd,1132	///  or in textual repr: transferFrom(address,address,uint256)1133	function transferFrom(1134		address from,1135		address to,1136		uint256 tokenId1137	) public {1138		require(false, stub_error);1139		from;1140		to;1141		tokenId;1142		dummy = 0;1143	}11441145	/// @notice Set or reaffirm the approved address for an NFT1146	/// @dev The zero address indicates there is no approved address.1147	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1148	///  operator of the current owner.1149	/// @param approved The new approved NFT controller1150	/// @param tokenId The NFT to approve1151	/// @dev EVM selector for this function is: 0x095ea7b3,1152	///  or in textual repr: approve(address,uint256)1153	function approve(address approved, uint256 tokenId) public {1154		require(false, stub_error);1155		approved;1156		tokenId;1157		dummy = 0;1158	}11591160	/// @notice Sets or unsets the approval of a given operator.1161	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1162	/// @param operator Operator1163	/// @param approved Should operator status be granted or revoked?1164	/// @dev EVM selector for this function is: 0xa22cb465,1165	///  or in textual repr: setApprovalForAll(address,bool)1166	function setApprovalForAll(address operator, bool approved) public {1167		require(false, stub_error);1168		operator;1169		approved;1170		dummy = 0;1171	}11721173	/// @notice Get the approved address for a single NFT1174	/// @dev Throws if `tokenId` is not a valid NFT1175	/// @param tokenId The NFT to find the approved address for1176	/// @return The approved address for this NFT, or the zero address if there is none1177	/// @dev EVM selector for this function is: 0x081812fc,1178	///  or in textual repr: getApproved(uint256)1179	function getApproved(uint256 tokenId) public view returns (address) {1180		require(false, stub_error);1181		tokenId;1182		dummy;1183		return 0x0000000000000000000000000000000000000000;1184	}11851186	/// @notice Tells whether the given `owner` approves the `operator`.1187	/// @dev EVM selector for this function is: 0xe985e9c5,1188	///  or in textual repr: isApprovedForAll(address,address)1189	function isApprovedForAll(address owner, address operator) public view returns (bool) {1190		require(false, stub_error);1191		owner;1192		operator;1193		dummy;1194		return false;1195	}1196}11971198contract UniqueNFT is1199	Dummy,1200	ERC165,1201	ERC721,1202	ERC721Enumerable,1203	ERC721UniqueExtensions,1204	ERC721UniqueMintable,1205	ERC721Burnable,1206	ERC721Metadata,1207	Collection,1208	TokenProperties1209{}