git.delta.rocks / unique-network / refs/commits / 2e0d1a668d33

1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8	uint8 dummy;9	string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13	function supportsInterface(bytes4 interfaceID) external view returns (bool) {14		require(false, stub_error);15		interfaceID;16		return true;17	}18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0x91a97a6822contract TokenProperties is Dummy, ERC165 {23	/// @notice Set permissions for token property.24	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.25	/// @param key Property key.26	/// @param isMutable Permission to mutate property.27	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.29	/// @dev EVM selector for this function is: 0x222d97fa,30	///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31	function setTokenPropertyPermission(32		string memory key,33		bool isMutable,34		bool collectionAdmin,35		bool tokenOwner36	) public {37		require(false, stub_error);38		key;39		isMutable;40		collectionAdmin;41		tokenOwner;42		dummy = 0;43	}4445	// /// @notice Set token property value.46	// /// @dev Throws error if `msg.sender` has no permission to edit the property.47	// /// @param tokenId ID of the token.48	// /// @param key Property key.49	// /// @param value Property value.50	// /// @dev EVM selector for this function is: 0x1752d67b,51	// ///  or in textual repr: setProperty(uint256,string,bytes)52	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {53	// 	require(false, stub_error);54	// 	tokenId;55	// 	key;56	// 	value;57	// 	dummy = 0;58	// }5960	/// @notice Set token properties value.61	/// @dev Throws error if `msg.sender` has no permission to edit the property.62	/// @param tokenId ID of the token.63	/// @param properties settable properties64	/// @dev EVM selector for this function is: 0x14ed3a6e,65	///  or in textual repr: setProperties(uint256,(string,bytes)[])66	function setProperties(uint256 tokenId, Property[] memory properties) public {67		require(false, stub_error);68		tokenId;69		properties;70		dummy = 0;71	}7273	// /// @notice Delete token property value.74	// /// @dev Throws error if `msg.sender` has no permission to edit the property.75	// /// @param tokenId ID of the token.76	// /// @param key Property key.77	// /// @dev EVM selector for this function is: 0x066111d1,78	// ///  or in textual repr: deleteProperty(uint256,string)79	// function deleteProperty(uint256 tokenId, string memory key) public {80	// 	require(false, stub_error);81	// 	tokenId;82	// 	key;83	// 	dummy = 0;84	// }8586	/// @notice Delete token properties value.87	/// @dev Throws error if `msg.sender` has no permission to edit the property.88	/// @param tokenId ID of the token.89	/// @param keys Properties key.90	/// @dev EVM selector for this function is: 0xc472d371,91	///  or in textual repr: deleteProperties(uint256,string[])92	function deleteProperties(uint256 tokenId, string[] memory keys) public {93		require(false, stub_error);94		tokenId;95		keys;96		dummy = 0;97	}9899	/// @notice Get token property value.100	/// @dev Throws error if key not found101	/// @param tokenId ID of the token.102	/// @param key Property key.103	/// @return Property value bytes104	/// @dev EVM selector for this function is: 0x7228c327,105	///  or in textual repr: property(uint256,string)106	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107		require(false, stub_error);108		tokenId;109		key;110		dummy;111		return hex"";112	}113}114115/// @dev Property struct116struct Property {117	string key;118	bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0x324a7f5b123contract Collection is Dummy, ERC165 {124	// /// Set collection property.125	// ///126	// /// @param key Property key.127	// /// @param value Propery value.128	// /// @dev EVM selector for this function is: 0x2f073f66,129	// ///  or in textual repr: setCollectionProperty(string,bytes)130	// function setCollectionProperty(string memory key, bytes memory value) public {131	// 	require(false, stub_error);132	// 	key;133	// 	value;134	// 	dummy = 0;135	// }136137	/// Set collection properties.138	///139	/// @param properties Vector of properties key/value pair.140	/// @dev EVM selector for this function is: 0x50b26b2a,141	///  or in textual repr: setCollectionProperties((string,bytes)[])142	function setCollectionProperties(Property[] memory properties) public {143		require(false, stub_error);144		properties;145		dummy = 0;146	}147148	// /// Delete collection property.149	// ///150	// /// @param key Property key.151	// /// @dev EVM selector for this function is: 0x7b7debce,152	// ///  or in textual repr: deleteCollectionProperty(string)153	// function deleteCollectionProperty(string memory key) public {154	// 	require(false, stub_error);155	// 	key;156	// 	dummy = 0;157	// }158159	/// Delete collection properties.160	///161	/// @param keys Properties keys.162	/// @dev EVM selector for this function is: 0xee206ee3,163	///  or in textual repr: deleteCollectionProperties(string[])164	function deleteCollectionProperties(string[] memory keys) public {165		require(false, stub_error);166		keys;167		dummy = 0;168	}169170	/// Get collection property.171	///172	/// @dev Throws error if key not found.173	///174	/// @param key Property key.175	/// @return bytes The property corresponding to the key.176	/// @dev EVM selector for this function is: 0xcf24fd6d,177	///  or in textual repr: collectionProperty(string)178	function collectionProperty(string memory key) public view returns (bytes memory) {179		require(false, stub_error);180		key;181		dummy;182		return hex"";183	}184185	/// Get collection properties.186	///187	/// @param keys Properties keys. Empty keys for all propertyes.188	/// @return Vector of properties key/value pairs.189	/// @dev EVM selector for this function is: 0x285fb8e6,190	///  or in textual repr: collectionProperties(string[])191	function collectionProperties(string[] memory keys) public view returns (Tuple23[] memory) {192		require(false, stub_error);193		keys;194		dummy;195		return new Tuple23[](0);196	}197198	// /// Set the sponsor of the collection.199	// ///200	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201	// ///202	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203	// /// @dev EVM selector for this function is: 0x7623402e,204	// ///  or in textual repr: setCollectionSponsor(address)205	// function setCollectionSponsor(address sponsor) public {206	// 	require(false, stub_error);207	// 	sponsor;208	// 	dummy = 0;209	// }210211	/// Set the sponsor of the collection.212	///213	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214	///215	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216	/// @dev EVM selector for this function is: 0x84a1d5a8,217	///  or in textual repr: setCollectionSponsorCross((address,uint256))218	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219		require(false, stub_error);220		sponsor;221		dummy = 0;222	}223224	/// Whether there is a pending sponsor.225	/// @dev EVM selector for this function is: 0x058ac185,226	///  or in textual repr: hasCollectionPendingSponsor()227	function hasCollectionPendingSponsor() public view returns (bool) {228		require(false, stub_error);229		dummy;230		return false;231	}232233	/// Collection sponsorship confirmation.234	///235	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.236	/// @dev EVM selector for this function is: 0x3c50e97a,237	///  or in textual repr: confirmCollectionSponsorship()238	function confirmCollectionSponsorship() public {239		require(false, stub_error);240		dummy = 0;241	}242243	/// Remove collection sponsor.244	/// @dev EVM selector for this function is: 0x6e0326a3,245	///  or in textual repr: removeCollectionSponsor()246	function removeCollectionSponsor() public {247		require(false, stub_error);248		dummy = 0;249	}250251	/// Get current sponsor.252	///253	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254	/// @dev EVM selector for this function is: 0x6ec0a9f1,255	///  or in textual repr: collectionSponsor()256	function collectionSponsor() public view returns (Tuple26 memory) {257		require(false, stub_error);258		dummy;259		return Tuple26(0x0000000000000000000000000000000000000000, 0);260	}261262	/// Set limits for the collection.263	/// @dev Throws error if limit not found.264	/// @param limit Name of the limit. Valid names:265	/// 	"accountTokenOwnershipLimit",266	/// 	"sponsoredDataSize",267	/// 	"sponsoredDataRateLimit",268	/// 	"tokenLimit",269	/// 	"sponsorTransferTimeout",270	/// 	"sponsorApproveTimeout"271	/// @param value Value of the limit.272	/// @dev EVM selector for this function is: 0x6a3841db,273	///  or in textual repr: setCollectionLimit(string,uint32)274	function setCollectionLimit(string memory limit, uint32 value) public {275		require(false, stub_error);276		limit;277		value;278		dummy = 0;279	}280281	/// Set limits for the collection.282	/// @dev Throws error if limit not found.283	/// @param limit Name of the limit. Valid names:284	/// 	"ownerCanTransfer",285	/// 	"ownerCanDestroy",286	/// 	"transfersEnabled"287	/// @param value Value of the limit.288	/// @dev EVM selector for this function is: 0x993b7fba,289	///  or in textual repr: setCollectionLimit(string,bool)290	function setCollectionLimit(string memory limit, bool value) public {291		require(false, stub_error);292		limit;293		value;294		dummy = 0;295	}296297	/// Get contract address.298	/// @dev EVM selector for this function is: 0xf6b4dfb4,299	///  or in textual repr: contractAddress()300	function contractAddress() public view returns (address) {301		require(false, stub_error);302		dummy;303		return 0x0000000000000000000000000000000000000000;304	}305306	/// Add collection admin.307	/// @param newAdmin Cross account administrator address.308	/// @dev EVM selector for this function is: 0x859aa7d6,309	///  or in textual repr: addCollectionAdminCross((address,uint256))310	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {311		require(false, stub_error);312		newAdmin;313		dummy = 0;314	}315316	/// Remove collection admin.317	/// @param admin Cross account administrator address.318	/// @dev EVM selector for this function is: 0x6c0cd173,319	///  or in textual repr: removeCollectionAdminCross((address,uint256))320	function removeCollectionAdminCross(EthCrossAccount memory admin) public {321		require(false, stub_error);322		admin;323		dummy = 0;324	}325326	// /// Add collection admin.327	// /// @param newAdmin Address of the added administrator.328	// /// @dev EVM selector for this function is: 0x92e462c7,329	// ///  or in textual repr: addCollectionAdmin(address)330	// function addCollectionAdmin(address newAdmin) public {331	// 	require(false, stub_error);332	// 	newAdmin;333	// 	dummy = 0;334	// }335336	// /// Remove collection admin.337	// ///338	// /// @param admin Address of the removed administrator.339	// /// @dev EVM selector for this function is: 0xfafd7b42,340	// ///  or in textual repr: removeCollectionAdmin(address)341	// function removeCollectionAdmin(address admin) public {342	// 	require(false, stub_error);343	// 	admin;344	// 	dummy = 0;345	// }346347	/// Toggle accessibility of collection nesting.348	///349	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'350	/// @dev EVM selector for this function is: 0x112d4586,351	///  or in textual repr: setCollectionNesting(bool)352	function setCollectionNesting(bool enable) public {353		require(false, stub_error);354		enable;355		dummy = 0;356	}357358	/// Toggle accessibility of collection nesting.359	///360	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'361	/// @param collections Addresses of collections that will be available for nesting.362	/// @dev EVM selector for this function is: 0x64872396,363	///  or in textual repr: setCollectionNesting(bool,address[])364	function setCollectionNesting(bool enable, address[] memory collections) public {365		require(false, stub_error);366		enable;367		collections;368		dummy = 0;369	}370371	/// Set the collection access method.372	/// @param mode Access mode373	/// 	0 for Normal374	/// 	1 for AllowList375	/// @dev EVM selector for this function is: 0x41835d4c,376	///  or in textual repr: setCollectionAccess(uint8)377	function setCollectionAccess(uint8 mode) public {378		require(false, stub_error);379		mode;380		dummy = 0;381	}382383	/// Checks that user allowed to operate with collection.384	///385	/// @param user User address to check.386	/// @dev EVM selector for this function is: 0xd63a8e11,387	///  or in textual repr: allowed(address)388	function allowed(address user) public view returns (bool) {389		require(false, stub_error);390		user;391		dummy;392		return false;393	}394395	// /// Add the user to the allowed list.396	// ///397	// /// @param user Address of a trusted user.398	// /// @dev EVM selector for this function is: 0x67844fe6,399	// ///  or in textual repr: addToCollectionAllowList(address)400	// function addToCollectionAllowList(address user) public {401	// 	require(false, stub_error);402	// 	user;403	// 	dummy = 0;404	// }405406	/// Add user to allowed list.407	///408	/// @param user User cross account address.409	/// @dev EVM selector for this function is: 0xa0184a3a,410	///  or in textual repr: addToCollectionAllowListCross((address,uint256))411	function addToCollectionAllowListCross(EthCrossAccount memory user) public {412		require(false, stub_error);413		user;414		dummy = 0;415	}416417	// /// Remove the user from the allowed list.418	// ///419	// /// @param user Address of a removed user.420	// /// @dev EVM selector for this function is: 0x85c51acb,421	// ///  or in textual repr: removeFromCollectionAllowList(address)422	// function removeFromCollectionAllowList(address user) public {423	// 	require(false, stub_error);424	// 	user;425	// 	dummy = 0;426	// }427428	/// Remove user from allowed list.429	///430	/// @param user User cross account address.431	/// @dev EVM selector for this function is: 0x09ba452a,432	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))433	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {434		require(false, stub_error);435		user;436		dummy = 0;437	}438439	/// Switch permission for minting.440	///441	/// @param mode Enable if "true".442	/// @dev EVM selector for this function is: 0x00018e84,443	///  or in textual repr: setCollectionMintMode(bool)444	function setCollectionMintMode(bool mode) public {445		require(false, stub_error);446		mode;447		dummy = 0;448	}449450	// /// Check that account is the owner or admin of the collection451	// ///452	// /// @param user account to verify453	// /// @return "true" if account is the owner or admin454	// /// @dev EVM selector for this function is: 0x9811b0c7,455	// ///  or in textual repr: isOwnerOrAdmin(address)456	// function isOwnerOrAdmin(address user) public view returns (bool) {457	// 	require(false, stub_error);458	// 	user;459	// 	dummy;460	// 	return false;461	// }462463	/// Check that account is the owner or admin of the collection464	///465	/// @param user User cross account to verify466	/// @return "true" if account is the owner or admin467	/// @dev EVM selector for this function is: 0x3e75a905,468	///  or in textual repr: isOwnerOrAdminCross((address,uint256))469	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {470		require(false, stub_error);471		user;472		dummy;473		return false;474	}475476	/// Returns collection type477	///478	/// @return `Fungible` or `NFT` or `ReFungible`479	/// @dev EVM selector for this function is: 0xd34b55b8,480	///  or in textual repr: uniqueCollectionType()481	function uniqueCollectionType() public view returns (string memory) {482		require(false, stub_error);483		dummy;484		return "";485	}486487	/// Get collection owner.488	///489	/// @return Tuble with sponsor address and his substrate mirror.490	/// If address is canonical then substrate mirror is zero and vice versa.491	/// @dev EVM selector for this function is: 0xdf727d3b,492	///  or in textual repr: collectionOwner()493	function collectionOwner() public view returns (EthCrossAccount memory) {494		require(false, stub_error);495		dummy;496		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);497	}498499	// /// Changes collection owner to another account500	// ///501	// /// @dev Owner can be changed only by current owner502	// /// @param newOwner new owner account503	// /// @dev EVM selector for this function is: 0x4f53e226,504	// ///  or in textual repr: changeCollectionOwner(address)505	// function changeCollectionOwner(address newOwner) public {506	// 	require(false, stub_error);507	// 	newOwner;508	// 	dummy = 0;509	// }510511	/// Get collection administrators512	///513	/// @return Vector of tuples with admins address and his substrate mirror.514	/// If address is canonical then substrate mirror is zero and vice versa.515	/// @dev EVM selector for this function is: 0x5813216b,516	///  or in textual repr: collectionAdmins()517	function collectionAdmins() public view returns (EthCrossAccount[] memory) {518		require(false, stub_error);519		dummy;520		return new EthCrossAccount[](0);521	}522523	/// Changes collection owner to another account524	///525	/// @dev Owner can be changed only by current owner526	/// @param newOwner new owner cross account527	/// @dev EVM selector for this function is: 0x6496c497,528	///  or in textual repr: changeCollectionOwnerCross((address,uint256))529	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {530		require(false, stub_error);531		newOwner;532		dummy = 0;533	}534}535536/// @dev Cross account struct537struct EthCrossAccount {538	address eth;539	uint256 sub;540}541542/// @dev anonymous struct543struct Tuple26 {544	address field_0;545	uint256 field_1;546}547548/// @dev anonymous struct549struct Tuple23 {550	string field_0;551	bytes field_1;552}553554/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension555/// @dev See https://eips.ethereum.org/EIPS/eip-721556/// @dev the ERC-165 identifier for this interface is 0x5b5e139f557contract ERC721Metadata is Dummy, ERC165 {558	// /// @notice A descriptive name for a collection of NFTs in this contract559	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`560	// /// @dev EVM selector for this function is: 0x06fdde03,561	// ///  or in textual repr: name()562	// function name() public view returns (string memory) {563	// 	require(false, stub_error);564	// 	dummy;565	// 	return "";566	// }567568	// /// @notice An abbreviated name for NFTs in this contract569	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`570	// /// @dev EVM selector for this function is: 0x95d89b41,571	// ///  or in textual repr: symbol()572	// function symbol() public view returns (string memory) {573	// 	require(false, stub_error);574	// 	dummy;575	// 	return "";576	// }577578	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.579	///580	/// @dev If the token has a `url` property and it is not empty, it is returned.581	///  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`.582	///  If the collection property `baseURI` is empty or absent, return "" (empty string)583	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix584	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).585	///586	/// @return token's const_metadata587	/// @dev EVM selector for this function is: 0xc87b56dd,588	///  or in textual repr: tokenURI(uint256)589	function tokenURI(uint256 tokenId) public view returns (string memory) {590		require(false, stub_error);591		tokenId;592		dummy;593		return "";594	}595}596597/// @title ERC721 Token that can be irreversibly burned (destroyed).598/// @dev the ERC-165 identifier for this interface is 0x42966c68599contract ERC721Burnable is Dummy, ERC165 {600	/// @notice Burns a specific ERC721 token.601	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized602	///  operator of the current owner.603	/// @param tokenId The NFT to approve604	/// @dev EVM selector for this function is: 0x42966c68,605	///  or in textual repr: burn(uint256)606	function burn(uint256 tokenId) public {607		require(false, stub_error);608		tokenId;609		dummy = 0;610	}611}612613/// @dev inlined interface614contract ERC721UniqueMintableEvents {615	event MintingFinished();616}617618/// @title ERC721 minting logic.619/// @dev the ERC-165 identifier for this interface is 0x476ff149620contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {621	/// @dev EVM selector for this function is: 0x05d2035b,622	///  or in textual repr: mintingFinished()623	function mintingFinished() public view returns (bool) {624		require(false, stub_error);625		dummy;626		return false;627	}628629	/// @notice Function to mint token.630	/// @param to The new owner631	/// @return uint256 The id of the newly minted token632	/// @dev EVM selector for this function is: 0x6a627842,633	///  or in textual repr: mint(address)634	function mint(address to) public returns (uint256) {635		require(false, stub_error);636		to;637		dummy = 0;638		return 0;639	}640641	// /// @notice Function to mint token.642	// /// @dev `tokenId` should be obtained with `nextTokenId` method,643	// ///  unlike standard, you can't specify it manually644	// /// @param to The new owner645	// /// @param tokenId ID of the minted NFT646	// /// @dev EVM selector for this function is: 0x40c10f19,647	// ///  or in textual repr: mint(address,uint256)648	// function mint(address to, uint256 tokenId) public returns (bool) {649	// 	require(false, stub_error);650	// 	to;651	// 	tokenId;652	// 	dummy = 0;653	// 	return false;654	// }655656	/// @notice Function to mint token with the given tokenUri.657	/// @param to The new owner658	/// @param tokenUri Token URI that would be stored in the NFT properties659	/// @return uint256 The id of the newly minted token660	/// @dev EVM selector for this function is: 0x45c17782,661	///  or in textual repr: mintWithTokenURI(address,string)662	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {663		require(false, stub_error);664		to;665		tokenUri;666		dummy = 0;667		return 0;668	}669670	// /// @notice Function to mint token with the given tokenUri.671	// /// @dev `tokenId` should be obtained with `nextTokenId` method,672	// ///  unlike standard, you can't specify it manually673	// /// @param to The new owner674	// /// @param tokenId ID of the minted NFT675	// /// @param tokenUri Token URI that would be stored in the NFT properties676	// /// @dev EVM selector for this function is: 0x50bb4e7f,677	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)678	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {679	// 	require(false, stub_error);680	// 	to;681	// 	tokenId;682	// 	tokenUri;683	// 	dummy = 0;684	// 	return false;685	// }686687	/// @dev Not implemented688	/// @dev EVM selector for this function is: 0x7d64bcb4,689	///  or in textual repr: finishMinting()690	function finishMinting() public returns (bool) {691		require(false, stub_error);692		dummy = 0;693		return false;694	}695}696697/// @title Unique extensions for ERC721.698/// @dev the ERC-165 identifier for this interface is 0x0e9fc611699contract ERC721UniqueExtensions is Dummy, ERC165 {700	/// @notice A descriptive name for a collection of NFTs in this contract701	/// @dev EVM selector for this function is: 0x06fdde03,702	///  or in textual repr: name()703	function name() public view returns (string memory) {704		require(false, stub_error);705		dummy;706		return "";707	}708709	/// @notice An abbreviated name for NFTs in this contract710	/// @dev EVM selector for this function is: 0x95d89b41,711	///  or in textual repr: symbol()712	function symbol() public view returns (string memory) {713		require(false, stub_error);714		dummy;715		return "";716	}717718	/// @notice Set or reaffirm the approved address for an NFT719	/// @dev The zero address indicates there is no approved address.720	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized721	///  operator of the current owner.722	/// @param approved The new substrate address approved NFT controller723	/// @param tokenId The NFT to approve724	/// @dev EVM selector for this function is: 0x0ecd0ab0,725	///  or in textual repr: approveCross((address,uint256),uint256)726	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {727		require(false, stub_error);728		approved;729		tokenId;730		dummy = 0;731	}732733	/// @notice Transfer ownership of an NFT734	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`735	///  is the zero address. Throws if `tokenId` is not a valid NFT.736	/// @param to The new owner737	/// @param tokenId The NFT to transfer738	/// @dev EVM selector for this function is: 0xa9059cbb,739	///  or in textual repr: transfer(address,uint256)740	function transfer(address to, uint256 tokenId) public {741		require(false, stub_error);742		to;743		tokenId;744		dummy = 0;745	}746747	/// @notice Transfer ownership of an NFT748	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`749	///  is the zero address. Throws if `tokenId` is not a valid NFT.750	/// @param to The new owner751	/// @param tokenId The NFT to transfer752	/// @dev EVM selector for this function is: 0x2ada85ff,753	///  or in textual repr: transferCross((address,uint256),uint256)754	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {755		require(false, stub_error);756		to;757		tokenId;758		dummy = 0;759	}760761	/// @notice Transfer ownership of an NFT from cross account address to cross account address762	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`763	///  is the zero address. Throws if `tokenId` is not a valid NFT.764	/// @param from Cross acccount address of current owner765	/// @param to Cross acccount address of new owner766	/// @param tokenId The NFT to transfer767	/// @dev EVM selector for this function is: 0xd5cf430b,768	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)769	function transferFromCross(770		EthCrossAccount memory from,771		EthCrossAccount memory to,772		uint256 tokenId773	) public {774		require(false, stub_error);775		from;776		to;777		tokenId;778		dummy = 0;779	}780781	// /// @notice Burns a specific ERC721 token.782	// /// @dev Throws unless `msg.sender` is the current owner or an authorized783	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws784	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.785	// /// @param from The current owner of the NFT786	// /// @param tokenId The NFT to transfer787	// /// @dev EVM selector for this function is: 0x79cc6790,788	// ///  or in textual repr: burnFrom(address,uint256)789	// function burnFrom(address from, uint256 tokenId) public {790	// 	require(false, stub_error);791	// 	from;792	// 	tokenId;793	// 	dummy = 0;794	// }795796	/// @notice Burns a specific ERC721 token.797	/// @dev Throws unless `msg.sender` is the current owner or an authorized798	///  operator for this NFT. Throws if `from` is not the current owner. Throws799	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.800	/// @param from The current owner of the NFT801	/// @param tokenId The NFT to transfer802	/// @dev EVM selector for this function is: 0xbb2f5a58,803	///  or in textual repr: burnFromCross((address,uint256),uint256)804	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {805		require(false, stub_error);806		from;807		tokenId;808		dummy = 0;809	}810811	/// @notice Returns next free NFT ID.812	/// @dev EVM selector for this function is: 0x75794a3c,813	///  or in textual repr: nextTokenId()814	function nextTokenId() public view returns (uint256) {815		require(false, stub_error);816		dummy;817		return 0;818	}819	// /// @notice Function to mint multiple tokens.820	// /// @dev `tokenIds` should be an array of consecutive numbers and first number821	// ///  should be obtained with `nextTokenId` method822	// /// @param to The new owner823	// /// @param tokenIds IDs of the minted NFTs824	// /// @dev EVM selector for this function is: 0x44a9945e,825	// ///  or in textual repr: mintBulk(address,uint256[])826	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {827	// 	require(false, stub_error);828	// 	to;829	// 	tokenIds;830	// 	dummy = 0;831	// 	return false;832	// }833834	// /// @notice Function to mint multiple tokens with the given tokenUris.835	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive836	// ///  numbers and first number should be obtained with `nextTokenId` method837	// /// @param to The new owner838	// /// @param tokens array of pairs of token ID and token URI for minted tokens839	// /// @dev EVM selector for this function is: 0x36543006,840	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])841	// function mintBulkWithTokenURI(address to, Tuple11[] memory tokens) public returns (bool) {842	// 	require(false, stub_error);843	// 	to;844	// 	tokens;845	// 	dummy = 0;846	// 	return false;847	// }848849}850851/// @dev anonymous struct852struct Tuple11 {853	uint256 field_0;854	string field_1;855}856857/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension858/// @dev See https://eips.ethereum.org/EIPS/eip-721859/// @dev the ERC-165 identifier for this interface is 0x780e9d63860contract ERC721Enumerable is Dummy, ERC165 {861	/// @notice Enumerate valid NFTs862	/// @param index A counter less than `totalSupply()`863	/// @return The token identifier for the `index`th NFT,864	///  (sort order not specified)865	/// @dev EVM selector for this function is: 0x4f6ccce7,866	///  or in textual repr: tokenByIndex(uint256)867	function tokenByIndex(uint256 index) public view returns (uint256) {868		require(false, stub_error);869		index;870		dummy;871		return 0;872	}873874	/// @dev Not implemented875	/// @dev EVM selector for this function is: 0x2f745c59,876	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)877	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {878		require(false, stub_error);879		owner;880		index;881		dummy;882		return 0;883	}884885	/// @notice Count NFTs tracked by this contract886	/// @return A count of valid NFTs tracked by this contract, where each one of887	///  them has an assigned and queryable owner not equal to the zero address888	/// @dev EVM selector for this function is: 0x18160ddd,889	///  or in textual repr: totalSupply()890	function totalSupply() public view returns (uint256) {891		require(false, stub_error);892		dummy;893		return 0;894	}895}896897/// @dev inlined interface898contract ERC721Events {899	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);900	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);901	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);902}903904/// @title ERC-721 Non-Fungible Token Standard905/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md906/// @dev the ERC-165 identifier for this interface is 0x80ac58cd907contract ERC721 is Dummy, ERC165, ERC721Events {908	/// @notice Count all NFTs assigned to an owner909	/// @dev NFTs assigned to the zero address are considered invalid, and this910	///  function throws for queries about the zero address.911	/// @param owner An address for whom to query the balance912	/// @return The number of NFTs owned by `owner`, possibly zero913	/// @dev EVM selector for this function is: 0x70a08231,914	///  or in textual repr: balanceOf(address)915	function balanceOf(address owner) public view returns (uint256) {916		require(false, stub_error);917		owner;918		dummy;919		return 0;920	}921922	/// @notice Find the owner of an NFT923	/// @dev NFTs assigned to zero address are considered invalid, and queries924	///  about them do throw.925	/// @param tokenId The identifier for an NFT926	/// @return The address of the owner of the NFT927	/// @dev EVM selector for this function is: 0x6352211e,928	///  or in textual repr: ownerOf(uint256)929	function ownerOf(uint256 tokenId) public view returns (address) {930		require(false, stub_error);931		tokenId;932		dummy;933		return 0x0000000000000000000000000000000000000000;934	}935936	/// @dev Not implemented937	/// @dev EVM selector for this function is: 0xb88d4fde,938	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)939	function safeTransferFrom(940		address from,941		address to,942		uint256 tokenId,943		bytes memory data944	) public {945		require(false, stub_error);946		from;947		to;948		tokenId;949		data;950		dummy = 0;951	}952953	/// @dev Not implemented954	/// @dev EVM selector for this function is: 0x42842e0e,955	///  or in textual repr: safeTransferFrom(address,address,uint256)956	function safeTransferFrom(957		address from,958		address to,959		uint256 tokenId960	) public {961		require(false, stub_error);962		from;963		to;964		tokenId;965		dummy = 0;966	}967968	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE969	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE970	///  THEY MAY BE PERMANENTLY LOST971	/// @dev Throws unless `msg.sender` is the current owner or an authorized972	///  operator for this NFT. Throws if `from` is not the current owner. Throws973	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.974	/// @param from The current owner of the NFT975	/// @param to The new owner976	/// @param tokenId The NFT to transfer977	/// @dev EVM selector for this function is: 0x23b872dd,978	///  or in textual repr: transferFrom(address,address,uint256)979	function transferFrom(980		address from,981		address to,982		uint256 tokenId983	) public {984		require(false, stub_error);985		from;986		to;987		tokenId;988		dummy = 0;989	}990991	/// @notice Set or reaffirm the approved address for an NFT992	/// @dev The zero address indicates there is no approved address.993	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized994	///  operator of the current owner.995	/// @param approved The new approved NFT controller996	/// @param tokenId The NFT to approve997	/// @dev EVM selector for this function is: 0x095ea7b3,998	///  or in textual repr: approve(address,uint256)999	function approve(address approved, uint256 tokenId) public {1000		require(false, stub_error);1001		approved;1002		tokenId;1003		dummy = 0;1004	}10051006	/// @dev Not implemented1007	/// @dev EVM selector for this function is: 0xa22cb465,1008	///  or in textual repr: setApprovalForAll(address,bool)1009	function setApprovalForAll(address operator, bool approved) public {1010		require(false, stub_error);1011		operator;1012		approved;1013		dummy = 0;1014	}10151016	/// @dev Not implemented1017	/// @dev EVM selector for this function is: 0x081812fc,1018	///  or in textual repr: getApproved(uint256)1019	function getApproved(uint256 tokenId) public view returns (address) {1020		require(false, stub_error);1021		tokenId;1022		dummy;1023		return 0x0000000000000000000000000000000000000000;1024	}10251026	/// @dev Not implemented1027	/// @dev EVM selector for this function is: 0xe985e9c5,1028	///  or in textual repr: isApprovedForAll(address,address)1029	function isApprovedForAll(address owner, address operator) public view returns (address) {1030		require(false, stub_error);1031		owner;1032		operator;1033		dummy;1034		return 0x0000000000000000000000000000000000000000;1035	}1036}10371038contract UniqueNFT is1039	Dummy,1040	ERC165,1041	ERC721,1042	ERC721Enumerable,1043	ERC721UniqueExtensions,1044	ERC721UniqueMintable,1045	ERC721Burnable,1046	ERC721Metadata,1047	Collection,1048	TokenProperties1049{}