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

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 0x307b061a778contract 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	/// Returns the owner (in cross format) of the token.819	///820	/// @param tokenId Id for the token.821	/// @dev EVM selector for this function is: 0xcaa3a4d0,822	///  or in textual repr: ownerOfCross(uint256)823	function ownerOfCross(uint256 tokenId) public view returns (CrossAddress memory) {824		require(false, stub_error);825		tokenId;826		dummy;827		return CrossAddress(0x0000000000000000000000000000000000000000, 0);828	}829830	/// @notice Count all NFTs assigned to an owner831	/// @param owner An cross address for whom to query the balance832	/// @return The number of NFTs owned by `owner`, possibly zero833	/// @dev EVM selector for this function is: 0xec069398,834	///  or in textual repr: balanceOfCross((address,uint256))835	function balanceOfCross(CrossAddress memory owner) public view returns (uint256) {836		require(false, stub_error);837		owner;838		dummy;839		return 0;840	}841842	/// Returns the token properties.843	///844	/// @param tokenId Id for the token.845	/// @param keys Properties keys. Empty keys for all propertyes.846	/// @return Vector of properties key/value pairs.847	/// @dev EVM selector for this function is: 0xe07ede7e,848	///  or in textual repr: properties(uint256,string[])849	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {850		require(false, stub_error);851		tokenId;852		keys;853		dummy;854		return new Property[](0);855	}856857	/// @notice Set or reaffirm the approved address for an NFT858	/// @dev The zero address indicates there is no approved address.859	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized860	///  operator of the current owner.861	/// @param approved The new substrate address approved NFT controller862	/// @param tokenId The NFT to approve863	/// @dev EVM selector for this function is: 0x0ecd0ab0,864	///  or in textual repr: approveCross((address,uint256),uint256)865	function approveCross(CrossAddress memory approved, uint256 tokenId) public {866		require(false, stub_error);867		approved;868		tokenId;869		dummy = 0;870	}871872	/// @notice Transfer ownership of an NFT873	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`874	///  is the zero address. Throws if `tokenId` is not a valid NFT.875	/// @param to The new owner876	/// @param tokenId The NFT to transfer877	/// @dev EVM selector for this function is: 0xa9059cbb,878	///  or in textual repr: transfer(address,uint256)879	function transfer(address to, uint256 tokenId) public {880		require(false, stub_error);881		to;882		tokenId;883		dummy = 0;884	}885886	/// @notice Transfer ownership of an NFT887	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`888	///  is the zero address. Throws if `tokenId` is not a valid NFT.889	/// @param to The new owner890	/// @param tokenId The NFT to transfer891	/// @dev EVM selector for this function is: 0x2ada85ff,892	///  or in textual repr: transferCross((address,uint256),uint256)893	function transferCross(CrossAddress memory to, uint256 tokenId) public {894		require(false, stub_error);895		to;896		tokenId;897		dummy = 0;898	}899900	/// @notice Transfer ownership of an NFT from cross account address to cross account address901	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`902	///  is the zero address. Throws if `tokenId` is not a valid NFT.903	/// @param from Cross acccount address of current owner904	/// @param to Cross acccount address of new owner905	/// @param tokenId The NFT to transfer906	/// @dev EVM selector for this function is: 0xd5cf430b,907	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)908	function transferFromCross(909		CrossAddress memory from,910		CrossAddress memory to,911		uint256 tokenId912	) public {913		require(false, stub_error);914		from;915		to;916		tokenId;917		dummy = 0;918	}919920	// /// @notice Burns a specific ERC721 token.921	// /// @dev Throws unless `msg.sender` is the current owner or an authorized922	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws923	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.924	// /// @param from The current owner of the NFT925	// /// @param tokenId The NFT to transfer926	// /// @dev EVM selector for this function is: 0x79cc6790,927	// ///  or in textual repr: burnFrom(address,uint256)928	// function burnFrom(address from, uint256 tokenId) public {929	// 	require(false, stub_error);930	// 	from;931	// 	tokenId;932	// 	dummy = 0;933	// }934935	/// @notice Burns a specific ERC721 token.936	/// @dev Throws unless `msg.sender` is the current owner or an authorized937	///  operator for this NFT. Throws if `from` is not the current owner. Throws938	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.939	/// @param from The current owner of the NFT940	/// @param tokenId The NFT to transfer941	/// @dev EVM selector for this function is: 0xbb2f5a58,942	///  or in textual repr: burnFromCross((address,uint256),uint256)943	function burnFromCross(CrossAddress memory from, uint256 tokenId) public {944		require(false, stub_error);945		from;946		tokenId;947		dummy = 0;948	}949950	/// @notice Returns next free NFT ID.951	/// @dev EVM selector for this function is: 0x75794a3c,952	///  or in textual repr: nextTokenId()953	function nextTokenId() public view returns (uint256) {954		require(false, stub_error);955		dummy;956		return 0;957	}958959	// /// @notice Function to mint multiple tokens.960	// /// @dev `tokenIds` should be an array of consecutive numbers and first number961	// ///  should be obtained with `nextTokenId` method962	// /// @param to The new owner963	// /// @param tokenIds IDs of the minted NFTs964	// /// @dev EVM selector for this function is: 0x44a9945e,965	// ///  or in textual repr: mintBulk(address,uint256[])966	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {967	// 	require(false, stub_error);968	// 	to;969	// 	tokenIds;970	// 	dummy = 0;971	// 	return false;972	// }973974	// /// @notice Function to mint multiple tokens with the given tokenUris.975	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive976	// ///  numbers and first number should be obtained with `nextTokenId` method977	// /// @param to The new owner978	// /// @param tokens array of pairs of token ID and token URI for minted tokens979	// /// @dev EVM selector for this function is: 0x36543006,980	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])981	// function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) public returns (bool) {982	// 	require(false, stub_error);983	// 	to;984	// 	tokens;985	// 	dummy = 0;986	// 	return false;987	// }988989	/// @notice Function to mint a token.990	/// @param to The new owner crossAccountId991	/// @param properties Properties of minted token992	/// @return uint256 The id of the newly minted token993	/// @dev EVM selector for this function is: 0xb904db03,994	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])995	function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {996		require(false, stub_error);997		to;998		properties;999		dummy = 0;1000		return 0;1001	}10021003	/// @notice Returns collection helper contract address1004	/// @dev EVM selector for this function is: 0x1896cce6,1005	///  or in textual repr: collectionHelperAddress()1006	function collectionHelperAddress() public view returns (address) {1007		require(false, stub_error);1008		dummy;1009		return 0x0000000000000000000000000000000000000000;1010	}1011}10121013/// Data for creation token with uri.1014struct TokenUri {1015	/// Id of new token.1016	uint256 id;1017	/// Uri of new token.1018	string uri;1019}10201021/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1022/// @dev See https://eips.ethereum.org/EIPS/eip-7211023/// @dev the ERC-165 identifier for this interface is 0x780e9d631024contract ERC721Enumerable is Dummy, ERC165 {1025	/// @notice Enumerate valid NFTs1026	/// @param index A counter less than `totalSupply()`1027	/// @return The token identifier for the `index`th NFT,1028	///  (sort order not specified)1029	/// @dev EVM selector for this function is: 0x4f6ccce7,1030	///  or in textual repr: tokenByIndex(uint256)1031	function tokenByIndex(uint256 index) public view returns (uint256) {1032		require(false, stub_error);1033		index;1034		dummy;1035		return 0;1036	}10371038	/// @dev Not implemented1039	/// @dev EVM selector for this function is: 0x2f745c59,1040	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1041	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1042		require(false, stub_error);1043		owner;1044		index;1045		dummy;1046		return 0;1047	}10481049	/// @notice Count NFTs tracked by this contract1050	/// @return A count of valid NFTs tracked by this contract, where each one of1051	///  them has an assigned and queryable owner not equal to the zero address1052	/// @dev EVM selector for this function is: 0x18160ddd,1053	///  or in textual repr: totalSupply()1054	function totalSupply() public view returns (uint256) {1055		require(false, stub_error);1056		dummy;1057		return 0;1058	}1059}10601061/// @dev inlined interface1062contract ERC721Events {1063	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1064	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1065	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1066}10671068/// @title ERC-721 Non-Fungible Token Standard1069/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1070/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1071contract ERC721 is Dummy, ERC165, ERC721Events {1072	/// @notice Count all NFTs assigned to an owner1073	/// @dev NFTs assigned to the zero address are considered invalid, and this1074	///  function throws for queries about the zero address.1075	/// @param owner An address for whom to query the balance1076	/// @return The number of NFTs owned by `owner`, possibly zero1077	/// @dev EVM selector for this function is: 0x70a08231,1078	///  or in textual repr: balanceOf(address)1079	function balanceOf(address owner) public view returns (uint256) {1080		require(false, stub_error);1081		owner;1082		dummy;1083		return 0;1084	}10851086	/// @notice Find the owner of an NFT1087	/// @dev NFTs assigned to zero address are considered invalid, and queries1088	///  about them do throw.1089	/// @param tokenId The identifier for an NFT1090	/// @return The address of the owner of the NFT1091	/// @dev EVM selector for this function is: 0x6352211e,1092	///  or in textual repr: ownerOf(uint256)1093	function ownerOf(uint256 tokenId) public view returns (address) {1094		require(false, stub_error);1095		tokenId;1096		dummy;1097		return 0x0000000000000000000000000000000000000000;1098	}10991100	/// @dev Not implemented1101	/// @dev EVM selector for this function is: 0xb88d4fde,1102	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)1103	function safeTransferFrom(1104		address from,1105		address to,1106		uint256 tokenId,1107		bytes memory data1108	) public {1109		require(false, stub_error);1110		from;1111		to;1112		tokenId;1113		data;1114		dummy = 0;1115	}11161117	/// @dev Not implemented1118	/// @dev EVM selector for this function is: 0x42842e0e,1119	///  or in textual repr: safeTransferFrom(address,address,uint256)1120	function safeTransferFrom(1121		address from,1122		address to,1123		uint256 tokenId1124	) public {1125		require(false, stub_error);1126		from;1127		to;1128		tokenId;1129		dummy = 0;1130	}11311132	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1133	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1134	///  THEY MAY BE PERMANENTLY LOST1135	/// @dev Throws unless `msg.sender` is the current owner or an authorized1136	///  operator for this NFT. Throws if `from` is not the current owner. Throws1137	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1138	/// @param from The current owner of the NFT1139	/// @param to The new owner1140	/// @param tokenId The NFT to transfer1141	/// @dev EVM selector for this function is: 0x23b872dd,1142	///  or in textual repr: transferFrom(address,address,uint256)1143	function transferFrom(1144		address from,1145		address to,1146		uint256 tokenId1147	) public {1148		require(false, stub_error);1149		from;1150		to;1151		tokenId;1152		dummy = 0;1153	}11541155	/// @notice Set or reaffirm the approved address for an NFT1156	/// @dev The zero address indicates there is no approved address.1157	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1158	///  operator of the current owner.1159	/// @param approved The new approved NFT controller1160	/// @param tokenId The NFT to approve1161	/// @dev EVM selector for this function is: 0x095ea7b3,1162	///  or in textual repr: approve(address,uint256)1163	function approve(address approved, uint256 tokenId) public {1164		require(false, stub_error);1165		approved;1166		tokenId;1167		dummy = 0;1168	}11691170	/// @notice Sets or unsets the approval of a given operator.1171	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1172	/// @param operator Operator1173	/// @param approved Should operator status be granted or revoked?1174	/// @dev EVM selector for this function is: 0xa22cb465,1175	///  or in textual repr: setApprovalForAll(address,bool)1176	function setApprovalForAll(address operator, bool approved) public {1177		require(false, stub_error);1178		operator;1179		approved;1180		dummy = 0;1181	}11821183	/// @notice Get the approved address for a single NFT1184	/// @dev Throws if `tokenId` is not a valid NFT1185	/// @param tokenId The NFT to find the approved address for1186	/// @return The approved address for this NFT, or the zero address if there is none1187	/// @dev EVM selector for this function is: 0x081812fc,1188	///  or in textual repr: getApproved(uint256)1189	function getApproved(uint256 tokenId) public view returns (address) {1190		require(false, stub_error);1191		tokenId;1192		dummy;1193		return 0x0000000000000000000000000000000000000000;1194	}11951196	/// @notice Tells whether the given `owner` approves the `operator`.1197	/// @dev EVM selector for this function is: 0xe985e9c5,1198	///  or in textual repr: isApprovedForAll(address,address)1199	function isApprovedForAll(address owner, address operator) public view returns (bool) {1200		require(false, stub_error);1201		owner;1202		operator;1203		dummy;1204		return false;1205	}1206}12071208contract UniqueNFT is1209	Dummy,1210	ERC165,1211	ERC721,1212	ERC721Enumerable,1213	ERC721UniqueExtensions,1214	ERC721UniqueMintable,1215	ERC721Burnable,1216	ERC721Metadata,1217	Collection,1218	TokenProperties1219{}