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

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 0x55dba91922contract 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(53		uint256 tokenId,54		string memory key,55		bytes memory value56	) public {57		require(false, stub_error);58		tokenId;59		key;60		value;61		dummy = 0;62	}6364	/// @notice Set token properties value.65	/// @dev Throws error if `msg.sender` has no permission to edit the property.66	/// @param tokenId ID of the token.67	/// @param properties settable properties68	/// @dev EVM selector for this function is: 0x14ed3a6e,69	///  or in textual repr: setProperties(uint256,(string,bytes)[])70	function setProperties(uint256 tokenId, Tuple21[] memory properties) public {71		require(false, stub_error);72		tokenId;73		properties;74		dummy = 0;75	}7677	/// @notice Delete token property value.78	/// @dev Throws error if `msg.sender` has no permission to edit the property.79	/// @param tokenId ID of the token.80	/// @param key Property key.81	/// @dev EVM selector for this function is: 0x066111d1,82	///  or in textual repr: deleteProperty(uint256,string)83	function deleteProperty(uint256 tokenId, string memory key) public {84		require(false, stub_error);85		tokenId;86		key;87		dummy = 0;88	}8990	/// @notice Get token property value.91	/// @dev Throws error if key not found92	/// @param tokenId ID of the token.93	/// @param key Property key.94	/// @return Property value bytes95	/// @dev EVM selector for this function is: 0x7228c327,96	///  or in textual repr: property(uint256,string)97	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {98		require(false, stub_error);99		tokenId;100		key;101		dummy;102		return hex"";103	}104}105106/// @title A contract that allows you to work with collections.107/// @dev the ERC-165 identifier for this interface is 0xb3152af3108contract Collection is Dummy, ERC165 {109	/// Set collection property.110	///111	/// @param key Property key.112	/// @param value Propery value.113	/// @dev EVM selector for this function is: 0x2f073f66,114	///  or in textual repr: setCollectionProperty(string,bytes)115	function setCollectionProperty(string memory key, bytes memory value) public {116		require(false, stub_error);117		key;118		value;119		dummy = 0;120	}121122	/// Set collection properties.123	///124	/// @param properties Vector of properties key/value pair.125	/// @dev EVM selector for this function is: 0x50b26b2a,126	///  or in textual repr: setCollectionProperties((string,bytes)[])127	function setCollectionProperties(Tuple21[] memory properties) public {128		require(false, stub_error);129		properties;130		dummy = 0;131	}132133	/// Delete collection property.134	///135	/// @param key Property key.136	/// @dev EVM selector for this function is: 0x7b7debce,137	///  or in textual repr: deleteCollectionProperty(string)138	function deleteCollectionProperty(string memory key) public {139		require(false, stub_error);140		key;141		dummy = 0;142	}143144	/// Delete collection properties.145	///146	/// @param keys Properties keys.147	/// @dev EVM selector for this function is: 0xee206ee3,148	///  or in textual repr: deleteCollectionProperties(string[])149	function deleteCollectionProperties(string[] memory keys) public {150		require(false, stub_error);151		keys;152		dummy = 0;153	}154155	/// Get collection property.156	///157	/// @dev Throws error if key not found.158	///159	/// @param key Property key.160	/// @return bytes The property corresponding to the key.161	/// @dev EVM selector for this function is: 0xcf24fd6d,162	///  or in textual repr: collectionProperty(string)163	function collectionProperty(string memory key) public view returns (bytes memory) {164		require(false, stub_error);165		key;166		dummy;167		return hex"";168	}169170	/// Get collection properties.171	///172	/// @param keys Properties keys. Empty keys for all propertyes.173	/// @return Vector of properties key/value pairs.174	/// @dev EVM selector for this function is: 0x285fb8e6,175	///  or in textual repr: collectionProperties(string[])176	function collectionProperties(string[] memory keys) public view returns (Tuple21[] memory) {177		require(false, stub_error);178		keys;179		dummy;180		return new Tuple21[](0);181	}182183	/// Set the sponsor of the collection.184	///185	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.186	///187	/// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.188	/// @dev EVM selector for this function is: 0x7623402e,189	///  or in textual repr: setCollectionSponsor(address)190	function setCollectionSponsor(address sponsor) public {191		require(false, stub_error);192		sponsor;193		dummy = 0;194	}195196	/// Set the sponsor of the collection.197	///198	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.199	///200	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.201	/// @dev EVM selector for this function is: 0x84a1d5a8,202	///  or in textual repr: setCollectionSponsorCross(EthCrossAccount)203	///  or in the expanded repr: setCollectionSponsorCross((address,uint256))204	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {205		require(false, stub_error);206		sponsor;207		dummy = 0;208	}209210	/// Whether there is a pending sponsor.211	/// @dev EVM selector for this function is: 0x058ac185,212	///  or in textual repr: hasCollectionPendingSponsor()213	function hasCollectionPendingSponsor() public view returns (bool) {214		require(false, stub_error);215		dummy;216		return false;217	}218219	/// Collection sponsorship confirmation.220	///221	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.222	/// @dev EVM selector for this function is: 0x3c50e97a,223	///  or in textual repr: confirmCollectionSponsorship()224	function confirmCollectionSponsorship() public {225		require(false, stub_error);226		dummy = 0;227	}228229	/// Remove collection sponsor.230	/// @dev EVM selector for this function is: 0x6e0326a3,231	///  or in textual repr: removeCollectionSponsor()232	function removeCollectionSponsor() public {233		require(false, stub_error);234		dummy = 0;235	}236237	/// Get current sponsor.238	///239	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.240	/// @dev EVM selector for this function is: 0x6ec0a9f1,241	///  or in textual repr: collectionSponsor()242	function collectionSponsor() public view returns (Tuple24 memory) {243		require(false, stub_error);244		dummy;245		return Tuple24(0x0000000000000000000000000000000000000000, 0);246	}247248	/// Set limits for the collection.249	/// @dev Throws error if limit not found.250	/// @param limit Name of the limit. Valid names:251	/// 	"accountTokenOwnershipLimit",252	/// 	"sponsoredDataSize",253	/// 	"sponsoredDataRateLimit",254	/// 	"tokenLimit",255	/// 	"sponsorTransferTimeout",256	/// 	"sponsorApproveTimeout"257	/// @param value Value of the limit.258	/// @dev EVM selector for this function is: 0x6a3841db,259	///  or in textual repr: setCollectionLimit(string,uint32)260	function setCollectionLimit(string memory limit, uint32 value) public {261		require(false, stub_error);262		limit;263		value;264		dummy = 0;265	}266267	/// Set limits for the collection.268	/// @dev Throws error if limit not found.269	/// @param limit Name of the limit. Valid names:270	/// 	"ownerCanTransfer",271	/// 	"ownerCanDestroy",272	/// 	"transfersEnabled"273	/// @param value Value of the limit.274	/// @dev EVM selector for this function is: 0x993b7fba,275	///  or in textual repr: setCollectionLimit(string,bool)276	function setCollectionLimit(string memory limit, bool value) public {277		require(false, stub_error);278		limit;279		value;280		dummy = 0;281	}282283	/// Get contract address.284	/// @dev EVM selector for this function is: 0xf6b4dfb4,285	///  or in textual repr: contractAddress()286	function contractAddress() public view returns (address) {287		require(false, stub_error);288		dummy;289		return 0x0000000000000000000000000000000000000000;290	}291292	/// Add collection admin.293	/// @param newAdmin Cross account administrator address.294	/// @dev EVM selector for this function is: 0x859aa7d6,295	///  or in textual repr: addCollectionAdminCross(EthCrossAccount)296	///  or in the expanded repr: addCollectionAdminCross((address,uint256))297	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {298		require(false, stub_error);299		newAdmin;300		dummy = 0;301	}302303	/// Remove collection admin.304	/// @param admin Cross account administrator address.305	/// @dev EVM selector for this function is: 0x6c0cd173,306	///  or in textual repr: removeCollectionAdminCross(EthCrossAccount)307	///  or in the expanded repr: removeCollectionAdminCross((address,uint256))308	function removeCollectionAdminCross(EthCrossAccount memory admin) public {309		require(false, stub_error);310		admin;311		dummy = 0;312	}313314	/// Add collection admin.315	/// @param newAdmin Address of the added administrator.316	/// @dev EVM selector for this function is: 0x92e462c7,317	///  or in textual repr: addCollectionAdmin(address)318	function addCollectionAdmin(address newAdmin) public {319		require(false, stub_error);320		newAdmin;321		dummy = 0;322	}323324	/// Remove collection admin.325	///326	/// @param admin Address of the removed administrator.327	/// @dev EVM selector for this function is: 0xfafd7b42,328	///  or in textual repr: removeCollectionAdmin(address)329	function removeCollectionAdmin(address admin) public {330		require(false, stub_error);331		admin;332		dummy = 0;333	}334335	/// Toggle accessibility of collection nesting.336	///337	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'338	/// @dev EVM selector for this function is: 0x112d4586,339	///  or in textual repr: setCollectionNesting(bool)340	function setCollectionNesting(bool enable) public {341		require(false, stub_error);342		enable;343		dummy = 0;344	}345346	/// Toggle accessibility of collection nesting.347	///348	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'349	/// @param collections Addresses of collections that will be available for nesting.350	/// @dev EVM selector for this function is: 0x64872396,351	///  or in textual repr: setCollectionNesting(bool,address[])352	function setCollectionNesting(bool enable, address[] memory collections) public {353		require(false, stub_error);354		enable;355		collections;356		dummy = 0;357	}358359	/// Set the collection access method.360	/// @param mode Access mode361	/// 	0 for Normal362	/// 	1 for AllowList363	/// @dev EVM selector for this function is: 0x41835d4c,364	///  or in textual repr: setCollectionAccess(uint8)365	function setCollectionAccess(uint8 mode) public {366		require(false, stub_error);367		mode;368		dummy = 0;369	}370371	/// Checks that user allowed to operate with collection.372	///373	/// @param user User address to check.374	/// @dev EVM selector for this function is: 0xd63a8e11,375	///  or in textual repr: allowed(address)376	function allowed(address user) public view returns (bool) {377		require(false, stub_error);378		user;379		dummy;380		return false;381	}382383	/// Add the user to the allowed list.384	///385	/// @param user Address of a trusted user.386	/// @dev EVM selector for this function is: 0x67844fe6,387	///  or in textual repr: addToCollectionAllowList(address)388	function addToCollectionAllowList(address user) public {389		require(false, stub_error);390		user;391		dummy = 0;392	}393394	/// Add user to allowed list.395	///396	/// @param user User cross account address.397	/// @dev EVM selector for this function is: 0xa0184a3a,398	///  or in textual repr: addToCollectionAllowListCross(EthCrossAccount)399	///  or in the expanded repr: addToCollectionAllowListCross((address,uint256))400	function addToCollectionAllowListCross(EthCrossAccount memory user) public {401		require(false, stub_error);402		user;403		dummy = 0;404	}405406	/// Remove the user from the allowed list.407	///408	/// @param user Address of a removed user.409	/// @dev EVM selector for this function is: 0x85c51acb,410	///  or in textual repr: removeFromCollectionAllowList(address)411	function removeFromCollectionAllowList(address user) public {412		require(false, stub_error);413		user;414		dummy = 0;415	}416417	/// Remove user from allowed list.418	///419	/// @param user User cross account address.420	/// @dev EVM selector for this function is: 0x09ba452a,421	///  or in textual repr: removeFromCollectionAllowListCross(EthCrossAccount)422	///  or in the expanded repr: removeFromCollectionAllowListCross((address,uint256))423	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {424		require(false, stub_error);425		user;426		dummy = 0;427	}428429	/// Switch permission for minting.430	///431	/// @param mode Enable if "true".432	/// @dev EVM selector for this function is: 0x00018e84,433	///  or in textual repr: setCollectionMintMode(bool)434	function setCollectionMintMode(bool mode) public {435		require(false, stub_error);436		mode;437		dummy = 0;438	}439440	/// Check that account is the owner or admin of the collection441	///442	/// @param user account to verify443	/// @return "true" if account is the owner or admin444	/// @dev EVM selector for this function is: 0x9811b0c7,445	///  or in textual repr: isOwnerOrAdmin(address)446	function isOwnerOrAdmin(address user) public view returns (bool) {447		require(false, stub_error);448		user;449		dummy;450		return false;451	}452453	/// Check that account is the owner or admin of the collection454	///455	/// @param user User cross account to verify456	/// @return "true" if account is the owner or admin457	/// @dev EVM selector for this function is: 0x3e75a905,458	///  or in textual repr: isOwnerOrAdminCross(EthCrossAccount)459	///  or in the expanded repr: isOwnerOrAdminCross((address,uint256))460	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {461		require(false, stub_error);462		user;463		dummy;464		return false;465	}466467	/// Returns collection type468	///469	/// @return `Fungible` or `NFT` or `ReFungible`470	/// @dev EVM selector for this function is: 0xd34b55b8,471	///  or in textual repr: uniqueCollectionType()472	function uniqueCollectionType() public view returns (string memory) {473		require(false, stub_error);474		dummy;475		return "";476	}477478	/// Get collection owner.479	///480	/// @return Tuble with sponsor address and his substrate mirror.481	/// If address is canonical then substrate mirror is zero and vice versa.482	/// @dev EVM selector for this function is: 0xdf727d3b,483	///  or in textual repr: collectionOwner()484	function collectionOwner() public view returns (EthCrossAccount memory) {485		require(false, stub_error);486		dummy;487		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);488	}489490	/// Changes collection owner to another account491	///492	/// @dev Owner can be changed only by current owner493	/// @param newOwner new owner account494	/// @dev EVM selector for this function is: 0x4f53e226,495	///  or in textual repr: changeCollectionOwner(address)496	function changeCollectionOwner(address newOwner) public {497		require(false, stub_error);498		newOwner;499		dummy = 0;500	}501502	/// Get collection administrators503	///504	/// @return Vector of tuples with admins address and his substrate mirror.505	/// If address is canonical then substrate mirror is zero and vice versa.506	/// @dev EVM selector for this function is: 0x5813216b,507	///  or in textual repr: collectionAdmins()508	function collectionAdmins() public view returns (EthCrossAccount[] memory) {509		require(false, stub_error);510		dummy;511		return new EthCrossAccount[](0);512	}513514	/// Changes collection owner to another account515	///516	/// @dev Owner can be changed only by current owner517	/// @param newOwner new owner cross account518	/// @dev EVM selector for this function is: 0xe5c9913f,519	///  or in textual repr: setOwnerCross(EthCrossAccount)520	///  or in the expanded repr: setOwnerCross((address,uint256))521	function setOwnerCross(EthCrossAccount memory newOwner) public {522		require(false, stub_error);523		newOwner;524		dummy = 0;525	}526}527528/// @dev Cross account struct529struct EthCrossAccount {530	address eth;531	uint256 sub;532}533534/// @dev anonymous struct535struct Tuple24 {536	address field_0;537	uint256 field_1;538}539540/// @dev anonymous struct541struct Tuple21 {542	string field_0;543	bytes field_1;544}545546/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension547/// @dev See https://eips.ethereum.org/EIPS/eip-721548/// @dev the ERC-165 identifier for this interface is 0x5b5e139f549contract ERC721Metadata is Dummy, ERC165 {550	// /// @notice A descriptive name for a collection of NFTs in this contract551	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`552	// /// @dev EVM selector for this function is: 0x06fdde03,553	// ///  or in textual repr: name()554	// function name() public view returns (string memory) {555	// 	require(false, stub_error);556	// 	dummy;557	// 	return "";558	// }559560	// /// @notice An abbreviated name for NFTs in this contract561	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`562	// /// @dev EVM selector for this function is: 0x95d89b41,563	// ///  or in textual repr: symbol()564	// function symbol() public view returns (string memory) {565	// 	require(false, stub_error);566	// 	dummy;567	// 	return "";568	// }569570	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.571	///572	/// @dev If the token has a `url` property and it is not empty, it is returned.573	///  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`.574	///  If the collection property `baseURI` is empty or absent, return "" (empty string)575	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix576	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).577	///578	/// @return token's const_metadata579	/// @dev EVM selector for this function is: 0xc87b56dd,580	///  or in textual repr: tokenURI(uint256)581	function tokenURI(uint256 tokenId) public view returns (string memory) {582		require(false, stub_error);583		tokenId;584		dummy;585		return "";586	}587}588589/// @title ERC721 Token that can be irreversibly burned (destroyed).590/// @dev the ERC-165 identifier for this interface is 0x42966c68591contract ERC721Burnable is Dummy, ERC165 {592	/// @notice Burns a specific ERC721 token.593	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized594	///  operator of the current owner.595	/// @param tokenId The NFT to approve596	/// @dev EVM selector for this function is: 0x42966c68,597	///  or in textual repr: burn(uint256)598	function burn(uint256 tokenId) public {599		require(false, stub_error);600		tokenId;601		dummy = 0;602	}603}604605/// @dev inlined interface606contract ERC721UniqueMintableEvents {607	event MintingFinished();608}609610/// @title ERC721 minting logic.611/// @dev the ERC-165 identifier for this interface is 0x476ff149612contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {613	/// @dev EVM selector for this function is: 0x05d2035b,614	///  or in textual repr: mintingFinished()615	function mintingFinished() public view returns (bool) {616		require(false, stub_error);617		dummy;618		return false;619	}620621	/// @notice Function to mint token.622	/// @param to The new owner623	/// @return uint256 The id of the newly minted token624	/// @dev EVM selector for this function is: 0x6a627842,625	///  or in textual repr: mint(address)626	function mint(address to) public returns (uint256) {627		require(false, stub_error);628		to;629		dummy = 0;630		return 0;631	}632633	// /// @notice Function to mint token.634	// /// @dev `tokenId` should be obtained with `nextTokenId` method,635	// ///  unlike standard, you can't specify it manually636	// /// @param to The new owner637	// /// @param tokenId ID of the minted NFT638	// /// @dev EVM selector for this function is: 0x40c10f19,639	// ///  or in textual repr: mint(address,uint256)640	// function mint(address to, uint256 tokenId) public returns (bool) {641	// 	require(false, stub_error);642	// 	to;643	// 	tokenId;644	// 	dummy = 0;645	// 	return false;646	// }647648	/// @notice Function to mint token with the given tokenUri.649	/// @param to The new owner650	/// @param tokenUri Token URI that would be stored in the NFT properties651	/// @return uint256 The id of the newly minted token652	/// @dev EVM selector for this function is: 0x45c17782,653	///  or in textual repr: mintWithTokenURI(address,string)654	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {655		require(false, stub_error);656		to;657		tokenUri;658		dummy = 0;659		return 0;660	}661662	// /// @notice Function to mint token with the given tokenUri.663	// /// @dev `tokenId` should be obtained with `nextTokenId` method,664	// ///  unlike standard, you can't specify it manually665	// /// @param to The new owner666	// /// @param tokenId ID of the minted NFT667	// /// @param tokenUri Token URI that would be stored in the NFT properties668	// /// @dev EVM selector for this function is: 0x50bb4e7f,669	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)670	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {671	// 	require(false, stub_error);672	// 	to;673	// 	tokenId;674	// 	tokenUri;675	// 	dummy = 0;676	// 	return false;677	// }678679	/// @dev Not implemented680	/// @dev EVM selector for this function is: 0x7d64bcb4,681	///  or in textual repr: finishMinting()682	function finishMinting() public returns (bool) {683		require(false, stub_error);684		dummy = 0;685		return false;686	}687}688689/// @title Unique extensions for ERC721.690/// @dev the ERC-165 identifier for this interface is 0x244543ee691contract ERC721UniqueExtensions is Dummy, ERC165 {692	/// @notice A descriptive name for a collection of NFTs in this contract693	/// @dev EVM selector for this function is: 0x06fdde03,694	///  or in textual repr: name()695	function name() public view returns (string memory) {696		require(false, stub_error);697		dummy;698		return "";699	}700701	/// @notice An abbreviated name for NFTs in this contract702	/// @dev EVM selector for this function is: 0x95d89b41,703	///  or in textual repr: symbol()704	function symbol() public view returns (string memory) {705		require(false, stub_error);706		dummy;707		return "";708	}709710	/// @notice Set or reaffirm the approved address for an NFT711	/// @dev The zero address indicates there is no approved address.712	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized713	///  operator of the current owner.714	/// @param approved The new substrate address approved NFT controller715	/// @param tokenId The NFT to approve716	/// @dev EVM selector for this function is: 0x0ecd0ab0,717	///  or in textual repr: approveCross(EthCrossAccount,uint256)718	///  or in the expanded repr: approveCross((address,uint256),uint256)719	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {720		require(false, stub_error);721		approved;722		tokenId;723		dummy = 0;724	}725726	/// @notice Transfer ownership of an NFT727	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`728	///  is the zero address. Throws if `tokenId` is not a valid NFT.729	/// @param to The new owner730	/// @param tokenId The NFT to transfer731	/// @dev EVM selector for this function is: 0xa9059cbb,732	///  or in textual repr: transfer(address,uint256)733	function transfer(address to, uint256 tokenId) public {734		require(false, stub_error);735		to;736		tokenId;737		dummy = 0;738	}739740	/// @notice Transfer ownership of an NFT from cross account address to cross account address741	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`742	///  is the zero address. Throws if `tokenId` is not a valid NFT.743	/// @param from Cross acccount address of current owner744	/// @param to Cross acccount address of new owner745	/// @param tokenId The NFT to transfer746	/// @dev EVM selector for this function is: 0xd5cf430b,747	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)748	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)749	function transferFromCross(750		EthCrossAccount memory from,751		EthCrossAccount memory to,752		uint256 tokenId753	) public {754		require(false, stub_error);755		from;756		to;757		tokenId;758		dummy = 0;759	}760761	/// @notice Burns a specific ERC721 token.762	/// @dev Throws unless `msg.sender` is the current owner or an authorized763	///  operator for this NFT. Throws if `from` is not the current owner. Throws764	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.765	/// @param from The current owner of the NFT766	/// @param tokenId The NFT to transfer767	/// @dev EVM selector for this function is: 0x79cc6790,768	///  or in textual repr: burnFrom(address,uint256)769	function burnFrom(address from, uint256 tokenId) public {770		require(false, stub_error);771		from;772		tokenId;773		dummy = 0;774	}775776	/// @notice Burns a specific ERC721 token.777	/// @dev Throws unless `msg.sender` is the current owner or an authorized778	///  operator for this NFT. Throws if `from` is not the current owner. Throws779	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.780	/// @param from The current owner of the NFT781	/// @param tokenId The NFT to transfer782	/// @dev EVM selector for this function is: 0xbb2f5a58,783	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)784	///  or in the expanded repr: burnFromCross((address,uint256),uint256)785	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {786		require(false, stub_error);787		from;788		tokenId;789		dummy = 0;790	}791792	/// @notice Returns next free NFT ID.793	/// @dev EVM selector for this function is: 0x75794a3c,794	///  or in textual repr: nextTokenId()795	function nextTokenId() public view returns (uint256) {796		require(false, stub_error);797		dummy;798		return 0;799	}800	// /// @notice Function to mint multiple tokens.801	// /// @dev `tokenIds` should be an array of consecutive numbers and first number802	// ///  should be obtained with `nextTokenId` method803	// /// @param to The new owner804	// /// @param tokenIds IDs of the minted NFTs805	// /// @dev EVM selector for this function is: 0x44a9945e,806	// ///  or in textual repr: mintBulk(address,uint256[])807	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {808	// 	require(false, stub_error);809	// 	to;810	// 	tokenIds;811	// 	dummy = 0;812	// 	return false;813	// }814815	// /// @notice Function to mint multiple tokens with the given tokenUris.816	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive817	// ///  numbers and first number should be obtained with `nextTokenId` method818	// /// @param to The new owner819	// /// @param tokens array of pairs of token ID and token URI for minted tokens820	// /// @dev EVM selector for this function is: 0x36543006,821	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])822	// function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) public returns (bool) {823	// 	require(false, stub_error);824	// 	to;825	// 	tokens;826	// 	dummy = 0;827	// 	return false;828	// }829830}831832/// @dev anonymous struct833struct Tuple10 {834	uint256 field_0;835	string field_1;836}837838/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension839/// @dev See https://eips.ethereum.org/EIPS/eip-721840/// @dev the ERC-165 identifier for this interface is 0x780e9d63841contract ERC721Enumerable is Dummy, ERC165 {842	/// @notice Enumerate valid NFTs843	/// @param index A counter less than `totalSupply()`844	/// @return The token identifier for the `index`th NFT,845	///  (sort order not specified)846	/// @dev EVM selector for this function is: 0x4f6ccce7,847	///  or in textual repr: tokenByIndex(uint256)848	function tokenByIndex(uint256 index) public view returns (uint256) {849		require(false, stub_error);850		index;851		dummy;852		return 0;853	}854855	/// @dev Not implemented856	/// @dev EVM selector for this function is: 0x2f745c59,857	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)858	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {859		require(false, stub_error);860		owner;861		index;862		dummy;863		return 0;864	}865866	/// @notice Count NFTs tracked by this contract867	/// @return A count of valid NFTs tracked by this contract, where each one of868	///  them has an assigned and queryable owner not equal to the zero address869	/// @dev EVM selector for this function is: 0x18160ddd,870	///  or in textual repr: totalSupply()871	function totalSupply() public view returns (uint256) {872		require(false, stub_error);873		dummy;874		return 0;875	}876}877878/// @dev inlined interface879contract ERC721Events {880	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);881	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);882	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);883}884885/// @title ERC-721 Non-Fungible Token Standard886/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md887/// @dev the ERC-165 identifier for this interface is 0x80ac58cd888contract ERC721 is Dummy, ERC165, ERC721Events {889	/// @notice Count all NFTs assigned to an owner890	/// @dev NFTs assigned to the zero address are considered invalid, and this891	///  function throws for queries about the zero address.892	/// @param owner An address for whom to query the balance893	/// @return The number of NFTs owned by `owner`, possibly zero894	/// @dev EVM selector for this function is: 0x70a08231,895	///  or in textual repr: balanceOf(address)896	function balanceOf(address owner) public view returns (uint256) {897		require(false, stub_error);898		owner;899		dummy;900		return 0;901	}902903	/// @notice Find the owner of an NFT904	/// @dev NFTs assigned to zero address are considered invalid, and queries905	///  about them do throw.906	/// @param tokenId The identifier for an NFT907	/// @return The address of the owner of the NFT908	/// @dev EVM selector for this function is: 0x6352211e,909	///  or in textual repr: ownerOf(uint256)910	function ownerOf(uint256 tokenId) public view returns (address) {911		require(false, stub_error);912		tokenId;913		dummy;914		return 0x0000000000000000000000000000000000000000;915	}916917	/// @dev Not implemented918	/// @dev EVM selector for this function is: 0xb88d4fde,919	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)920	function safeTransferFrom(921		address from,922		address to,923		uint256 tokenId,924		bytes memory data925	) public {926		require(false, stub_error);927		from;928		to;929		tokenId;930		data;931		dummy = 0;932	}933934	/// @dev Not implemented935	/// @dev EVM selector for this function is: 0x42842e0e,936	///  or in textual repr: safeTransferFrom(address,address,uint256)937	function safeTransferFrom(938		address from,939		address to,940		uint256 tokenId941	) public {942		require(false, stub_error);943		from;944		to;945		tokenId;946		dummy = 0;947	}948949	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE950	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE951	///  THEY MAY BE PERMANENTLY LOST952	/// @dev Throws unless `msg.sender` is the current owner or an authorized953	///  operator for this NFT. Throws if `from` is not the current owner. Throws954	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.955	/// @param from The current owner of the NFT956	/// @param to The new owner957	/// @param tokenId The NFT to transfer958	/// @dev EVM selector for this function is: 0x23b872dd,959	///  or in textual repr: transferFrom(address,address,uint256)960	function transferFrom(961		address from,962		address to,963		uint256 tokenId964	) public {965		require(false, stub_error);966		from;967		to;968		tokenId;969		dummy = 0;970	}971972	/// @notice Set or reaffirm the approved address for an NFT973	/// @dev The zero address indicates there is no approved address.974	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized975	///  operator of the current owner.976	/// @param approved The new approved NFT controller977	/// @param tokenId The NFT to approve978	/// @dev EVM selector for this function is: 0x095ea7b3,979	///  or in textual repr: approve(address,uint256)980	function approve(address approved, uint256 tokenId) public {981		require(false, stub_error);982		approved;983		tokenId;984		dummy = 0;985	}986987	/// @dev Not implemented988	/// @dev EVM selector for this function is: 0xa22cb465,989	///  or in textual repr: setApprovalForAll(address,bool)990	function setApprovalForAll(address operator, bool approved) public {991		require(false, stub_error);992		operator;993		approved;994		dummy = 0;995	}996997	/// @dev Not implemented998	/// @dev EVM selector for this function is: 0x081812fc,999	///  or in textual repr: getApproved(uint256)1000	function getApproved(uint256 tokenId) public view returns (address) {1001		require(false, stub_error);1002		tokenId;1003		dummy;1004		return 0x0000000000000000000000000000000000000000;1005	}10061007	/// @dev Not implemented1008	/// @dev EVM selector for this function is: 0xe985e9c5,1009	///  or in textual repr: isApprovedForAll(address,address)1010	function isApprovedForAll(address owner, address operator) public view returns (address) {1011		require(false, stub_error);1012		owner;1013		operator;1014		dummy;1015		return 0x0000000000000000000000000000000000000000;1016	}1017}10181019contract UniqueNFT is1020	Dummy,1021	ERC165,1022	ERC721,1023	ERC721Enumerable,1024	ERC721UniqueExtensions,1025	ERC721UniqueMintable,1026	ERC721Burnable,1027	ERC721Metadata,1028	Collection,1029	TokenProperties1030{}