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

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(address indexed collectionId, uint256 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 0x16de3152778contract 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 token properties.819	///820	/// @param tokenId Id for the token.821	/// @param keys Properties keys. Empty keys for all propertyes.822	/// @return Vector of properties key/value pairs.823	/// @dev EVM selector for this function is: 0xe07ede7e,824	///  or in textual repr: properties(uint256,string[])825	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {826		require(false, stub_error);827		tokenId;828		keys;829		dummy;830		return new Property[](0);831	}832833	/// @notice Set or reaffirm the approved address for an NFT834	/// @dev The zero address indicates there is no approved address.835	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized836	///  operator of the current owner.837	/// @param approved The new substrate address approved NFT controller838	/// @param tokenId The NFT to approve839	/// @dev EVM selector for this function is: 0x0ecd0ab0,840	///  or in textual repr: approveCross((address,uint256),uint256)841	function approveCross(CrossAddress memory approved, uint256 tokenId) public {842		require(false, stub_error);843		approved;844		tokenId;845		dummy = 0;846	}847848	/// @notice Transfer ownership of an NFT849	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`850	///  is the zero address. Throws if `tokenId` is not a valid NFT.851	/// @param to The new owner852	/// @param tokenId The NFT to transfer853	/// @dev EVM selector for this function is: 0xa9059cbb,854	///  or in textual repr: transfer(address,uint256)855	function transfer(address to, uint256 tokenId) public {856		require(false, stub_error);857		to;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: 0x2ada85ff,868	///  or in textual repr: transferCross((address,uint256),uint256)869	function transferCross(CrossAddress memory to, uint256 tokenId) public {870		require(false, stub_error);871		to;872		tokenId;873		dummy = 0;874	}875876	/// @notice Transfer ownership of an NFT from cross account address to cross account address877	/// @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 from Cross acccount address of current owner880	/// @param to Cross acccount address of new owner881	/// @param tokenId The NFT to transfer882	/// @dev EVM selector for this function is: 0xd5cf430b,883	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)884	function transferFromCross(885		CrossAddress memory from,886		CrossAddress memory to,887		uint256 tokenId888	) public {889		require(false, stub_error);890		from;891		to;892		tokenId;893		dummy = 0;894	}895896	// /// @notice Burns a specific ERC721 token.897	// /// @dev Throws unless `msg.sender` is the current owner or an authorized898	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws899	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.900	// /// @param from The current owner of the NFT901	// /// @param tokenId The NFT to transfer902	// /// @dev EVM selector for this function is: 0x79cc6790,903	// ///  or in textual repr: burnFrom(address,uint256)904	// function burnFrom(address from, uint256 tokenId) public {905	// 	require(false, stub_error);906	// 	from;907	// 	tokenId;908	// 	dummy = 0;909	// }910911	/// @notice Burns a specific ERC721 token.912	/// @dev Throws unless `msg.sender` is the current owner or an authorized913	///  operator for this NFT. Throws if `from` is not the current owner. Throws914	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.915	/// @param from The current owner of the NFT916	/// @param tokenId The NFT to transfer917	/// @dev EVM selector for this function is: 0xbb2f5a58,918	///  or in textual repr: burnFromCross((address,uint256),uint256)919	function burnFromCross(CrossAddress memory from, uint256 tokenId) public {920		require(false, stub_error);921		from;922		tokenId;923		dummy = 0;924	}925926	/// @notice Returns next free NFT ID.927	/// @dev EVM selector for this function is: 0x75794a3c,928	///  or in textual repr: nextTokenId()929	function nextTokenId() public view returns (uint256) {930		require(false, stub_error);931		dummy;932		return 0;933	}934935	// /// @notice Function to mint multiple tokens.936	// /// @dev `tokenIds` should be an array of consecutive numbers and first number937	// ///  should be obtained with `nextTokenId` method938	// /// @param to The new owner939	// /// @param tokenIds IDs of the minted NFTs940	// /// @dev EVM selector for this function is: 0x44a9945e,941	// ///  or in textual repr: mintBulk(address,uint256[])942	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {943	// 	require(false, stub_error);944	// 	to;945	// 	tokenIds;946	// 	dummy = 0;947	// 	return false;948	// }949950	// /// @notice Function to mint multiple tokens with the given tokenUris.951	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive952	// ///  numbers and first number should be obtained with `nextTokenId` method953	// /// @param to The new owner954	// /// @param tokens array of pairs of token ID and token URI for minted tokens955	// /// @dev EVM selector for this function is: 0x36543006,956	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])957	// function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) public returns (bool) {958	// 	require(false, stub_error);959	// 	to;960	// 	tokens;961	// 	dummy = 0;962	// 	return false;963	// }964965	/// @notice Function to mint a token.966	/// @param to The new owner crossAccountId967	/// @param properties Properties of minted token968	/// @return uint256 The id of the newly minted token969	/// @dev EVM selector for this function is: 0xb904db03,970	///  or in textual repr: mintCross((address,uint256),(string,bytes)[])971	function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {972		require(false, stub_error);973		to;974		properties;975		dummy = 0;976		return 0;977	}978979	/// @notice Returns collection helper contract address980	/// @dev EVM selector for this function is: 0x1896cce6,981	///  or in textual repr: collectionHelperAddress()982	function collectionHelperAddress() public view returns (address) {983		require(false, stub_error);984		dummy;985		return 0x0000000000000000000000000000000000000000;986	}987}988989/// Data for creation token with uri.990struct TokenUri {991	/// Id of new token.992	uint256 id;993	/// Uri of new token.994	string uri;995}996997/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension998/// @dev See https://eips.ethereum.org/EIPS/eip-721999/// @dev the ERC-165 identifier for this interface is 0x780e9d631000contract ERC721Enumerable is Dummy, ERC165 {1001	/// @notice Enumerate valid NFTs1002	/// @param index A counter less than `totalSupply()`1003	/// @return The token identifier for the `index`th NFT,1004	///  (sort order not specified)1005	/// @dev EVM selector for this function is: 0x4f6ccce7,1006	///  or in textual repr: tokenByIndex(uint256)1007	function tokenByIndex(uint256 index) public view returns (uint256) {1008		require(false, stub_error);1009		index;1010		dummy;1011		return 0;1012	}10131014	/// @dev Not implemented1015	/// @dev EVM selector for this function is: 0x2f745c59,1016	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1017	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1018		require(false, stub_error);1019		owner;1020		index;1021		dummy;1022		return 0;1023	}10241025	/// @notice Count NFTs tracked by this contract1026	/// @return A count of valid NFTs tracked by this contract, where each one of1027	///  them has an assigned and queryable owner not equal to the zero address1028	/// @dev EVM selector for this function is: 0x18160ddd,1029	///  or in textual repr: totalSupply()1030	function totalSupply() public view returns (uint256) {1031		require(false, stub_error);1032		dummy;1033		return 0;1034	}1035}10361037/// @dev inlined interface1038contract ERC721Events {1039	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1040	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1041	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1042}10431044/// @title ERC-721 Non-Fungible Token Standard1045/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1046/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1047contract ERC721 is Dummy, ERC165, ERC721Events {1048	/// @notice Count all NFTs assigned to an owner1049	/// @dev NFTs assigned to the zero address are considered invalid, and this1050	///  function throws for queries about the zero address.1051	/// @param owner An address for whom to query the balance1052	/// @return The number of NFTs owned by `owner`, possibly zero1053	/// @dev EVM selector for this function is: 0x70a08231,1054	///  or in textual repr: balanceOf(address)1055	function balanceOf(address owner) public view returns (uint256) {1056		require(false, stub_error);1057		owner;1058		dummy;1059		return 0;1060	}10611062	/// @notice Find the owner of an NFT1063	/// @dev NFTs assigned to zero address are considered invalid, and queries1064	///  about them do throw.1065	/// @param tokenId The identifier for an NFT1066	/// @return The address of the owner of the NFT1067	/// @dev EVM selector for this function is: 0x6352211e,1068	///  or in textual repr: ownerOf(uint256)1069	function ownerOf(uint256 tokenId) public view returns (address) {1070		require(false, stub_error);1071		tokenId;1072		dummy;1073		return 0x0000000000000000000000000000000000000000;1074	}10751076	/// @dev Not implemented1077	/// @dev EVM selector for this function is: 0xb88d4fde,1078	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)1079	function safeTransferFrom(1080		address from,1081		address to,1082		uint256 tokenId,1083		bytes memory data1084	) public {1085		require(false, stub_error);1086		from;1087		to;1088		tokenId;1089		data;1090		dummy = 0;1091	}10921093	/// @dev Not implemented1094	/// @dev EVM selector for this function is: 0x42842e0e,1095	///  or in textual repr: safeTransferFrom(address,address,uint256)1096	function safeTransferFrom(1097		address from,1098		address to,1099		uint256 tokenId1100	) public {1101		require(false, stub_error);1102		from;1103		to;1104		tokenId;1105		dummy = 0;1106	}11071108	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1109	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1110	///  THEY MAY BE PERMANENTLY LOST1111	/// @dev Throws unless `msg.sender` is the current owner or an authorized1112	///  operator for this NFT. Throws if `from` is not the current owner. Throws1113	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1114	/// @param from The current owner of the NFT1115	/// @param to The new owner1116	/// @param tokenId The NFT to transfer1117	/// @dev EVM selector for this function is: 0x23b872dd,1118	///  or in textual repr: transferFrom(address,address,uint256)1119	function transferFrom(1120		address from,1121		address to,1122		uint256 tokenId1123	) public {1124		require(false, stub_error);1125		from;1126		to;1127		tokenId;1128		dummy = 0;1129	}11301131	/// @notice Set or reaffirm the approved address for an NFT1132	/// @dev The zero address indicates there is no approved address.1133	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1134	///  operator of the current owner.1135	/// @param approved The new approved NFT controller1136	/// @param tokenId The NFT to approve1137	/// @dev EVM selector for this function is: 0x095ea7b3,1138	///  or in textual repr: approve(address,uint256)1139	function approve(address approved, uint256 tokenId) public {1140		require(false, stub_error);1141		approved;1142		tokenId;1143		dummy = 0;1144	}11451146	/// @notice Sets or unsets the approval of a given operator.1147	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1148	/// @param operator Operator1149	/// @param approved Should operator status be granted or revoked?1150	/// @dev EVM selector for this function is: 0xa22cb465,1151	///  or in textual repr: setApprovalForAll(address,bool)1152	function setApprovalForAll(address operator, bool approved) public {1153		require(false, stub_error);1154		operator;1155		approved;1156		dummy = 0;1157	}11581159	/// @dev Not implemented1160	/// @dev EVM selector for this function is: 0x081812fc,1161	///  or in textual repr: getApproved(uint256)1162	function getApproved(uint256 tokenId) public view returns (address) {1163		require(false, stub_error);1164		tokenId;1165		dummy;1166		return 0x0000000000000000000000000000000000000000;1167	}11681169	/// @notice Tells whether the given `owner` approves the `operator`.1170	/// @dev EVM selector for this function is: 0xe985e9c5,1171	///  or in textual repr: isApprovedForAll(address,address)1172	function isApprovedForAll(address owner, address operator) public view returns (bool) {1173		require(false, stub_error);1174		owner;1175		operator;1176		dummy;1177		return false;1178	}1179}11801181contract UniqueNFT is1182	Dummy,1183	ERC165,1184	ERC721,1185	ERC721Enumerable,1186	ERC721UniqueExtensions,1187	ERC721UniqueMintable,1188	ERC721Burnable,1189	ERC721Metadata,1190	Collection,1191	TokenProperties1192{}