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

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 0xde0695c222contract 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(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {32	// 	require(false, stub_error);33	// 	key;34	// 	isMutable;35	// 	collectionAdmin;36	// 	tokenOwner;37	// 	dummy = 0;38	// }3940	/// @notice Set permissions for token property.41	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.42	/// @param permissions Permissions for keys.43	/// @dev EVM selector for this function is: 0xbd92983a,44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])45	function setTokenPropertyPermissions(Tuple53[] memory permissions) public {46		require(false, stub_error);47		permissions;48		dummy = 0;49	}5051	/// @notice Get permissions for token properties.52	/// @dev EVM selector for this function is: 0xf23d7790,53	///  or in textual repr: tokenPropertyPermissions()54	function tokenPropertyPermissions() public view returns (Tuple53[] memory) {55		require(false, stub_error);56		dummy;57		return new Tuple53[](0);58	}5960	// /// @notice Set token property value.61	// /// @dev Throws error if `msg.sender` has no permission to edit the property.62	// /// @param tokenId ID of the token.63	// /// @param key Property key.64	// /// @param value Property value.65	// /// @dev EVM selector for this function is: 0x1752d67b,66	// ///  or in textual repr: setProperty(uint256,string,bytes)67	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {68	// 	require(false, stub_error);69	// 	tokenId;70	// 	key;71	// 	value;72	// 	dummy = 0;73	// }7475	/// @notice Set token properties value.76	/// @dev Throws error if `msg.sender` has no permission to edit the property.77	/// @param tokenId ID of the token.78	/// @param properties settable properties79	/// @dev EVM selector for this function is: 0x14ed3a6e,80	///  or in textual repr: setProperties(uint256,(string,bytes)[])81	function setProperties(uint256 tokenId, Property[] memory properties) public {82		require(false, stub_error);83		tokenId;84		properties;85		dummy = 0;86	}8788	// /// @notice Delete token property value.89	// /// @dev Throws error if `msg.sender` has no permission to edit the property.90	// /// @param tokenId ID of the token.91	// /// @param key Property key.92	// /// @dev EVM selector for this function is: 0x066111d1,93	// ///  or in textual repr: deleteProperty(uint256,string)94	// function deleteProperty(uint256 tokenId, string memory key) public {95	// 	require(false, stub_error);96	// 	tokenId;97	// 	key;98	// 	dummy = 0;99	// }100101	/// @notice Delete token properties value.102	/// @dev Throws error if `msg.sender` has no permission to edit the property.103	/// @param tokenId ID of the token.104	/// @param keys Properties key.105	/// @dev EVM selector for this function is: 0xc472d371,106	///  or in textual repr: deleteProperties(uint256,string[])107	function deleteProperties(uint256 tokenId, string[] memory keys) public {108		require(false, stub_error);109		tokenId;110		keys;111		dummy = 0;112	}113114	/// @notice Get token property value.115	/// @dev Throws error if key not found116	/// @param tokenId ID of the token.117	/// @param key Property key.118	/// @return Property value bytes119	/// @dev EVM selector for this function is: 0x7228c327,120	///  or in textual repr: property(uint256,string)121	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {122		require(false, stub_error);123		tokenId;124		key;125		dummy;126		return hex"";127	}128}129130/// @dev Property struct131struct Property {132	string key;133	bytes value;134}135136enum EthTokenPermissions {137	Mutable,138	TokenOwner,139	CollectionAdmin140}141142/// @dev anonymous struct143struct Tuple53 {144	string field_0;145	Tuple51[] field_1;146}147148/// @dev anonymous struct149struct Tuple51 {150	EthTokenPermissions field_0;151	bool field_1;152}153154/// @title A contract that allows you to work with collections.155/// @dev the ERC-165 identifier for this interface is 0xb5e1747f156contract Collection is Dummy, ERC165 {157	// /// Set collection property.158	// ///159	// /// @param key Property key.160	// /// @param value Propery value.161	// /// @dev EVM selector for this function is: 0x2f073f66,162	// ///  or in textual repr: setCollectionProperty(string,bytes)163	// function setCollectionProperty(string memory key, bytes memory value) public {164	// 	require(false, stub_error);165	// 	key;166	// 	value;167	// 	dummy = 0;168	// }169170	/// Set collection properties.171	///172	/// @param properties Vector of properties key/value pair.173	/// @dev EVM selector for this function is: 0x50b26b2a,174	///  or in textual repr: setCollectionProperties((string,bytes)[])175	function setCollectionProperties(Property[] memory properties) public {176		require(false, stub_error);177		properties;178		dummy = 0;179	}180181	// /// Delete collection property.182	// ///183	// /// @param key Property key.184	// /// @dev EVM selector for this function is: 0x7b7debce,185	// ///  or in textual repr: deleteCollectionProperty(string)186	// function deleteCollectionProperty(string memory key) public {187	// 	require(false, stub_error);188	// 	key;189	// 	dummy = 0;190	// }191192	/// Delete collection properties.193	///194	/// @param keys Properties keys.195	/// @dev EVM selector for this function is: 0xee206ee3,196	///  or in textual repr: deleteCollectionProperties(string[])197	function deleteCollectionProperties(string[] memory keys) public {198		require(false, stub_error);199		keys;200		dummy = 0;201	}202203	/// Get collection property.204	///205	/// @dev Throws error if key not found.206	///207	/// @param key Property key.208	/// @return bytes The property corresponding to the key.209	/// @dev EVM selector for this function is: 0xcf24fd6d,210	///  or in textual repr: collectionProperty(string)211	function collectionProperty(string memory key) public view returns (bytes memory) {212		require(false, stub_error);213		key;214		dummy;215		return hex"";216	}217218	/// Get collection properties.219	///220	/// @param keys Properties keys. Empty keys for all propertyes.221	/// @return Vector of properties key/value pairs.222	/// @dev EVM selector for this function is: 0x285fb8e6,223	///  or in textual repr: collectionProperties(string[])224	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {225		require(false, stub_error);226		keys;227		dummy;228		return new Property[](0);229	}230231	// /// Set the sponsor of the collection.232	// ///233	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.234	// ///235	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.236	// /// @dev EVM selector for this function is: 0x7623402e,237	// ///  or in textual repr: setCollectionSponsor(address)238	// function setCollectionSponsor(address sponsor) public {239	// 	require(false, stub_error);240	// 	sponsor;241	// 	dummy = 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 Cross account address of the sponsor from whose account funds will be debited for operations with the contract.249	/// @dev EVM selector for this function is: 0x84a1d5a8,250	///  or in textual repr: setCollectionSponsorCross((address,uint256))251	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {252		require(false, stub_error);253		sponsor;254		dummy = 0;255	}256257	/// Whether there is a pending sponsor.258	/// @dev EVM selector for this function is: 0x058ac185,259	///  or in textual repr: hasCollectionPendingSponsor()260	function hasCollectionPendingSponsor() public view returns (bool) {261		require(false, stub_error);262		dummy;263		return false;264	}265266	/// Collection sponsorship confirmation.267	///268	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.269	/// @dev EVM selector for this function is: 0x3c50e97a,270	///  or in textual repr: confirmCollectionSponsorship()271	function confirmCollectionSponsorship() public {272		require(false, stub_error);273		dummy = 0;274	}275276	/// Remove collection sponsor.277	/// @dev EVM selector for this function is: 0x6e0326a3,278	///  or in textual repr: removeCollectionSponsor()279	function removeCollectionSponsor() public {280		require(false, stub_error);281		dummy = 0;282	}283284	/// Get current sponsor.285	///286	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.287	/// @dev EVM selector for this function is: 0x6ec0a9f1,288	///  or in textual repr: collectionSponsor()289	function collectionSponsor() public view returns (Tuple29 memory) {290		require(false, stub_error);291		dummy;292		return Tuple29(0x0000000000000000000000000000000000000000, 0);293	}294295	/// Set limits for the collection.296	/// @dev Throws error if limit not found.297	/// @param limit Name of the limit. Valid names:298	/// 	"accountTokenOwnershipLimit",299	/// 	"sponsoredDataSize",300	/// 	"sponsoredDataRateLimit",301	/// 	"tokenLimit",302	/// 	"sponsorTransferTimeout",303	/// 	"sponsorApproveTimeout"304	///  	"ownerCanTransfer",305	/// 	"ownerCanDestroy",306	/// 	"transfersEnabled"307	/// @param value Value of the limit.308	/// @dev EVM selector for this function is: 0x4ad890a8,309	///  or in textual repr: setCollectionLimit(string,uint256)310	function setCollectionLimit(string memory limit, uint256 value) public {311		require(false, stub_error);312		limit;313		value;314		dummy = 0;315	}316317	/// Get contract address.318	/// @dev EVM selector for this function is: 0xf6b4dfb4,319	///  or in textual repr: contractAddress()320	function contractAddress() public view returns (address) {321		require(false, stub_error);322		dummy;323		return 0x0000000000000000000000000000000000000000;324	}325326	/// Add collection admin.327	/// @param newAdmin Cross account administrator address.328	/// @dev EVM selector for this function is: 0x859aa7d6,329	///  or in textual repr: addCollectionAdminCross((address,uint256))330	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {331		require(false, stub_error);332		newAdmin;333		dummy = 0;334	}335336	/// Remove collection admin.337	/// @param admin Cross account administrator address.338	/// @dev EVM selector for this function is: 0x6c0cd173,339	///  or in textual repr: removeCollectionAdminCross((address,uint256))340	function removeCollectionAdminCross(EthCrossAccount memory admin) public {341		require(false, stub_error);342		admin;343		dummy = 0;344	}345346	// /// Add collection admin.347	// /// @param newAdmin Address of the added administrator.348	// /// @dev EVM selector for this function is: 0x92e462c7,349	// ///  or in textual repr: addCollectionAdmin(address)350	// function addCollectionAdmin(address newAdmin) public {351	// 	require(false, stub_error);352	// 	newAdmin;353	// 	dummy = 0;354	// }355356	// /// Remove collection admin.357	// ///358	// /// @param admin Address of the removed administrator.359	// /// @dev EVM selector for this function is: 0xfafd7b42,360	// ///  or in textual repr: removeCollectionAdmin(address)361	// function removeCollectionAdmin(address admin) public {362	// 	require(false, stub_error);363	// 	admin;364	// 	dummy = 0;365	// }366367	/// Toggle accessibility of collection nesting.368	///369	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'370	/// @dev EVM selector for this function is: 0x112d4586,371	///  or in textual repr: setCollectionNesting(bool)372	function setCollectionNesting(bool enable) public {373		require(false, stub_error);374		enable;375		dummy = 0;376	}377378	/// Toggle accessibility of collection nesting.379	///380	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'381	/// @param collections Addresses of collections that will be available for nesting.382	/// @dev EVM selector for this function is: 0x64872396,383	///  or in textual repr: setCollectionNesting(bool,address[])384	function setCollectionNesting(bool enable, address[] memory collections) public {385		require(false, stub_error);386		enable;387		collections;388		dummy = 0;389	}390391	/// Returns nesting for a collection392	/// @dev EVM selector for this function is: 0x22d25bfe,393	///  or in textual repr: collectionNestingRestrictedCollectionIds()394	function collectionNestingRestrictedCollectionIds() public view returns (Tuple33 memory) {395		require(false, stub_error);396		dummy;397		return Tuple33(false, new uint256[](0));398	}399400	/// Returns permissions for a collection401	/// @dev EVM selector for this function is: 0x5b2eaf4b,402	///  or in textual repr: collectionNestingPermissions()403	function collectionNestingPermissions() public view returns (Tuple36[] memory) {404		require(false, stub_error);405		dummy;406		return new Tuple36[](0);407	}408409	/// Set the collection access method.410	/// @param mode Access mode411	/// 	0 for Normal412	/// 	1 for AllowList413	/// @dev EVM selector for this function is: 0x41835d4c,414	///  or in textual repr: setCollectionAccess(uint8)415	function setCollectionAccess(uint8 mode) public {416		require(false, stub_error);417		mode;418		dummy = 0;419	}420421	/// Checks that user allowed to operate with collection.422	///423	/// @param user User address to check.424	/// @dev EVM selector for this function is: 0x91b6df49,425	///  or in textual repr: allowlistedCross((address,uint256))426	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {427		require(false, stub_error);428		user;429		dummy;430		return false;431	}432433	// /// Add the user to the allowed list.434	// ///435	// /// @param user Address of a trusted user.436	// /// @dev EVM selector for this function is: 0x67844fe6,437	// ///  or in textual repr: addToCollectionAllowList(address)438	// function addToCollectionAllowList(address user) public {439	// 	require(false, stub_error);440	// 	user;441	// 	dummy = 0;442	// }443444	/// Add user to allowed list.445	///446	/// @param user User cross account address.447	/// @dev EVM selector for this function is: 0xa0184a3a,448	///  or in textual repr: addToCollectionAllowListCross((address,uint256))449	function addToCollectionAllowListCross(EthCrossAccount memory user) public {450		require(false, stub_error);451		user;452		dummy = 0;453	}454455	// /// Remove the user from the allowed list.456	// ///457	// /// @param user Address of a removed user.458	// /// @dev EVM selector for this function is: 0x85c51acb,459	// ///  or in textual repr: removeFromCollectionAllowList(address)460	// function removeFromCollectionAllowList(address user) public {461	// 	require(false, stub_error);462	// 	user;463	// 	dummy = 0;464	// }465466	/// Remove user from allowed list.467	///468	/// @param user User cross account address.469	/// @dev EVM selector for this function is: 0x09ba452a,470	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))471	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {472		require(false, stub_error);473		user;474		dummy = 0;475	}476477	/// Switch permission for minting.478	///479	/// @param mode Enable if "true".480	/// @dev EVM selector for this function is: 0x00018e84,481	///  or in textual repr: setCollectionMintMode(bool)482	function setCollectionMintMode(bool mode) public {483		require(false, stub_error);484		mode;485		dummy = 0;486	}487488	// /// Check that account is the owner or admin of the collection489	// ///490	// /// @param user account to verify491	// /// @return "true" if account is the owner or admin492	// /// @dev EVM selector for this function is: 0x9811b0c7,493	// ///  or in textual repr: isOwnerOrAdmin(address)494	// function isOwnerOrAdmin(address user) public view returns (bool) {495	// 	require(false, stub_error);496	// 	user;497	// 	dummy;498	// 	return false;499	// }500501	/// Check that account is the owner or admin of the collection502	///503	/// @param user User cross account to verify504	/// @return "true" if account is the owner or admin505	/// @dev EVM selector for this function is: 0x3e75a905,506	///  or in textual repr: isOwnerOrAdminCross((address,uint256))507	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {508		require(false, stub_error);509		user;510		dummy;511		return false;512	}513514	/// Returns collection type515	///516	/// @return `Fungible` or `NFT` or `ReFungible`517	/// @dev EVM selector for this function is: 0xd34b55b8,518	///  or in textual repr: uniqueCollectionType()519	function uniqueCollectionType() public view returns (string memory) {520		require(false, stub_error);521		dummy;522		return "";523	}524525	/// Get collection owner.526	///527	/// @return Tuble with sponsor address and his substrate mirror.528	/// If address is canonical then substrate mirror is zero and vice versa.529	/// @dev EVM selector for this function is: 0xdf727d3b,530	///  or in textual repr: collectionOwner()531	function collectionOwner() public view returns (EthCrossAccount memory) {532		require(false, stub_error);533		dummy;534		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);535	}536537	// /// Changes collection owner to another account538	// ///539	// /// @dev Owner can be changed only by current owner540	// /// @param newOwner new owner account541	// /// @dev EVM selector for this function is: 0x4f53e226,542	// ///  or in textual repr: changeCollectionOwner(address)543	// function changeCollectionOwner(address newOwner) public {544	// 	require(false, stub_error);545	// 	newOwner;546	// 	dummy = 0;547	// }548549	/// Get collection administrators550	///551	/// @return Vector of tuples with admins address and his substrate mirror.552	/// If address is canonical then substrate mirror is zero and vice versa.553	/// @dev EVM selector for this function is: 0x5813216b,554	///  or in textual repr: collectionAdmins()555	function collectionAdmins() public view returns (EthCrossAccount[] memory) {556		require(false, stub_error);557		dummy;558		return new EthCrossAccount[](0);559	}560561	/// Changes collection owner to another account562	///563	/// @dev Owner can be changed only by current owner564	/// @param newOwner new owner cross account565	/// @dev EVM selector for this function is: 0x6496c497,566	///  or in textual repr: changeCollectionOwnerCross((address,uint256))567	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {568		require(false, stub_error);569		newOwner;570		dummy = 0;571	}572}573574/// @dev Cross account struct575struct EthCrossAccount {576	address eth;577	uint256 sub;578}579580enum CollectionPermissions {581	CollectionAdmin,582	TokenOwner583}584585/// @dev anonymous struct586struct Tuple36 {587	CollectionPermissions field_0;588	bool field_1;589}590591/// @dev anonymous struct592struct Tuple33 {593	bool field_0;594	uint256[] field_1;595}596597/// @dev anonymous struct598struct Tuple29 {599	address field_0;600	uint256 field_1;601}602603/// @dev the ERC-165 identifier for this interface is 0x5b5e139f604contract ERC721Metadata is Dummy, ERC165 {605	// /// @notice A descriptive name for a collection of NFTs in this contract606	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`607	// /// @dev EVM selector for this function is: 0x06fdde03,608	// ///  or in textual repr: name()609	// function name() public view returns (string memory) {610	// 	require(false, stub_error);611	// 	dummy;612	// 	return "";613	// }614615	// /// @notice An abbreviated name for NFTs in this contract616	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`617	// /// @dev EVM selector for this function is: 0x95d89b41,618	// ///  or in textual repr: symbol()619	// function symbol() public view returns (string memory) {620	// 	require(false, stub_error);621	// 	dummy;622	// 	return "";623	// }624625	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.626	///627	/// @dev If the token has a `url` property and it is not empty, it is returned.628	///  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`.629	///  If the collection property `baseURI` is empty or absent, return "" (empty string)630	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix631	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).632	///633	/// @return token's const_metadata634	/// @dev EVM selector for this function is: 0xc87b56dd,635	///  or in textual repr: tokenURI(uint256)636	function tokenURI(uint256 tokenId) public view returns (string memory) {637		require(false, stub_error);638		tokenId;639		dummy;640		return "";641	}642}643644/// @title ERC721 Token that can be irreversibly burned (destroyed).645/// @dev the ERC-165 identifier for this interface is 0x42966c68646contract ERC721Burnable is Dummy, ERC165 {647	/// @notice Burns a specific ERC721 token.648	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized649	///  operator of the current owner.650	/// @param tokenId The RFT to approve651	/// @dev EVM selector for this function is: 0x42966c68,652	///  or in textual repr: burn(uint256)653	function burn(uint256 tokenId) public {654		require(false, stub_error);655		tokenId;656		dummy = 0;657	}658}659660/// @dev inlined interface661contract ERC721UniqueMintableEvents {662	event MintingFinished();663}664665/// @title ERC721 minting logic.666/// @dev the ERC-165 identifier for this interface is 0x476ff149667contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {668	/// @dev EVM selector for this function is: 0x05d2035b,669	///  or in textual repr: mintingFinished()670	function mintingFinished() public view returns (bool) {671		require(false, stub_error);672		dummy;673		return false;674	}675676	/// @notice Function to mint token.677	/// @param to The new owner678	/// @return uint256 The id of the newly minted token679	/// @dev EVM selector for this function is: 0x6a627842,680	///  or in textual repr: mint(address)681	function mint(address to) public returns (uint256) {682		require(false, stub_error);683		to;684		dummy = 0;685		return 0;686	}687688	// /// @notice Function to mint token.689	// /// @dev `tokenId` should be obtained with `nextTokenId` method,690	// ///  unlike standard, you can't specify it manually691	// /// @param to The new owner692	// /// @param tokenId ID of the minted RFT693	// /// @dev EVM selector for this function is: 0x40c10f19,694	// ///  or in textual repr: mint(address,uint256)695	// function mint(address to, uint256 tokenId) public returns (bool) {696	// 	require(false, stub_error);697	// 	to;698	// 	tokenId;699	// 	dummy = 0;700	// 	return false;701	// }702703	/// @notice Function to mint token with the given tokenUri.704	/// @param to The new owner705	/// @param tokenUri Token URI that would be stored in the NFT properties706	/// @return uint256 The id of the newly minted token707	/// @dev EVM selector for this function is: 0x45c17782,708	///  or in textual repr: mintWithTokenURI(address,string)709	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {710		require(false, stub_error);711		to;712		tokenUri;713		dummy = 0;714		return 0;715	}716717	// /// @notice Function to mint token with the given tokenUri.718	// /// @dev `tokenId` should be obtained with `nextTokenId` method,719	// ///  unlike standard, you can't specify it manually720	// /// @param to The new owner721	// /// @param tokenId ID of the minted RFT722	// /// @param tokenUri Token URI that would be stored in the RFT properties723	// /// @dev EVM selector for this function is: 0x50bb4e7f,724	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)725	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {726	// 	require(false, stub_error);727	// 	to;728	// 	tokenId;729	// 	tokenUri;730	// 	dummy = 0;731	// 	return false;732	// }733734	/// @dev Not implemented735	/// @dev EVM selector for this function is: 0x7d64bcb4,736	///  or in textual repr: finishMinting()737	function finishMinting() public returns (bool) {738		require(false, stub_error);739		dummy = 0;740		return false;741	}742}743744/// @title Unique extensions for ERC721.745/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1746contract ERC721UniqueExtensions is Dummy, ERC165 {747	/// @notice A descriptive name for a collection of NFTs in this contract748	/// @dev EVM selector for this function is: 0x06fdde03,749	///  or in textual repr: name()750	function name() public view returns (string memory) {751		require(false, stub_error);752		dummy;753		return "";754	}755756	/// @notice An abbreviated name for NFTs in this contract757	/// @dev EVM selector for this function is: 0x95d89b41,758	///  or in textual repr: symbol()759	function symbol() public view returns (string memory) {760		require(false, stub_error);761		dummy;762		return "";763	}764765	/// @notice A description for the collection.766	/// @dev EVM selector for this function is: 0x7284e416,767	///  or in textual repr: description()768	function description() public view returns (string memory) {769		require(false, stub_error);770		dummy;771		return "";772	}773774	/// Returns the owner (in cross format) of the token.775	///776	/// @param tokenId Id for the token.777	/// @dev EVM selector for this function is: 0x2b29dace,778	///  or in textual repr: crossOwnerOf(uint256)779	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {780		require(false, stub_error);781		tokenId;782		dummy;783		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);784	}785786	/// Returns the token properties.787	///788	/// @param tokenId Id for the token.789	/// @param keys Properties keys. Empty keys for all propertyes.790	/// @return Vector of properties key/value pairs.791	/// @dev EVM selector for this function is: 0xe07ede7e,792	///  or in textual repr: properties(uint256,string[])793	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {794		require(false, stub_error);795		tokenId;796		keys;797		dummy;798		return new Property[](0);799	}800801	/// @notice Transfer ownership of an RFT802	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`803	///  is the zero address. Throws if `tokenId` is not a valid RFT.804	///  Throws if RFT pieces have multiple owners.805	/// @param to The new owner806	/// @param tokenId The RFT to transfer807	/// @dev EVM selector for this function is: 0xa9059cbb,808	///  or in textual repr: transfer(address,uint256)809	function transfer(address to, uint256 tokenId) public {810		require(false, stub_error);811		to;812		tokenId;813		dummy = 0;814	}815816	/// @notice Transfer ownership of an RFT817	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`818	///  is the zero address. Throws if `tokenId` is not a valid RFT.819	///  Throws if RFT pieces have multiple owners.820	/// @param to The new owner821	/// @param tokenId The RFT to transfer822	/// @dev EVM selector for this function is: 0x2ada85ff,823	///  or in textual repr: transferCross((address,uint256),uint256)824	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {825		require(false, stub_error);826		to;827		tokenId;828		dummy = 0;829	}830831	/// @notice Transfer ownership of an RFT832	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`833	///  is the zero address. Throws if `tokenId` is not a valid RFT.834	///  Throws if RFT pieces have multiple owners.835	/// @param to The new owner836	/// @param tokenId The RFT to transfer837	/// @dev EVM selector for this function is: 0xd5cf430b,838	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)839	function transferFromCross(840		EthCrossAccount memory from,841		EthCrossAccount memory to,842		uint256 tokenId843	) public {844		require(false, stub_error);845		from;846		to;847		tokenId;848		dummy = 0;849	}850851	// /// @notice Burns a specific ERC721 token.852	// /// @dev Throws unless `msg.sender` is the current owner or an authorized853	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws854	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.855	// ///  Throws if RFT pieces have multiple owners.856	// /// @param from The current owner of the RFT857	// /// @param tokenId The RFT to transfer858	// /// @dev EVM selector for this function is: 0x79cc6790,859	// ///  or in textual repr: burnFrom(address,uint256)860	// function burnFrom(address from, uint256 tokenId) public {861	// 	require(false, stub_error);862	// 	from;863	// 	tokenId;864	// 	dummy = 0;865	// }866867	/// @notice Burns a specific ERC721 token.868	/// @dev Throws unless `msg.sender` is the current owner or an authorized869	///  operator for this RFT. Throws if `from` is not the current owner. Throws870	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.871	///  Throws if RFT pieces have multiple owners.872	/// @param from The current owner of the RFT873	/// @param tokenId The RFT to transfer874	/// @dev EVM selector for this function is: 0xbb2f5a58,875	///  or in textual repr: burnFromCross((address,uint256),uint256)876	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {877		require(false, stub_error);878		from;879		tokenId;880		dummy = 0;881	}882883	/// @notice Returns next free RFT ID.884	/// @dev EVM selector for this function is: 0x75794a3c,885	///  or in textual repr: nextTokenId()886	function nextTokenId() public view returns (uint256) {887		require(false, stub_error);888		dummy;889		return 0;890	}891892	// /// @notice Function to mint multiple tokens.893	// /// @dev `tokenIds` should be an array of consecutive numbers and first number894	// ///  should be obtained with `nextTokenId` method895	// /// @param to The new owner896	// /// @param tokenIds IDs of the minted RFTs897	// /// @dev EVM selector for this function is: 0x44a9945e,898	// ///  or in textual repr: mintBulk(address,uint256[])899	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {900	// 	require(false, stub_error);901	// 	to;902	// 	tokenIds;903	// 	dummy = 0;904	// 	return false;905	// }906907	// /// @notice Function to mint multiple tokens with the given tokenUris.908	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive909	// ///  numbers and first number should be obtained with `nextTokenId` method910	// /// @param to The new owner911	// /// @param tokens array of pairs of token ID and token URI for minted tokens912	// /// @dev EVM selector for this function is: 0x36543006,913	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])914	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {915	// 	require(false, stub_error);916	// 	to;917	// 	tokens;918	// 	dummy = 0;919	// 	return false;920	// }921922	/// Returns EVM address for refungible token923	///924	/// @param token ID of the token925	/// @dev EVM selector for this function is: 0xab76fac6,926	///  or in textual repr: tokenContractAddress(uint256)927	function tokenContractAddress(uint256 token) public view returns (address) {928		require(false, stub_error);929		token;930		dummy;931		return 0x0000000000000000000000000000000000000000;932	}933}934935/// @dev anonymous struct936struct Tuple14 {937	uint256 field_0;938	string field_1;939}940941/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension942/// @dev See https://eips.ethereum.org/EIPS/eip-721943/// @dev the ERC-165 identifier for this interface is 0x780e9d63944contract ERC721Enumerable is Dummy, ERC165 {945	/// @notice Enumerate valid RFTs946	/// @param index A counter less than `totalSupply()`947	/// @return The token identifier for the `index`th NFT,948	///  (sort order not specified)949	/// @dev EVM selector for this function is: 0x4f6ccce7,950	///  or in textual repr: tokenByIndex(uint256)951	function tokenByIndex(uint256 index) public view returns (uint256) {952		require(false, stub_error);953		index;954		dummy;955		return 0;956	}957958	/// Not implemented959	/// @dev EVM selector for this function is: 0x2f745c59,960	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)961	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {962		require(false, stub_error);963		owner;964		index;965		dummy;966		return 0;967	}968969	/// @notice Count RFTs tracked by this contract970	/// @return A count of valid RFTs tracked by this contract, where each one of971	///  them has an assigned and queryable owner not equal to the zero address972	/// @dev EVM selector for this function is: 0x18160ddd,973	///  or in textual repr: totalSupply()974	function totalSupply() public view returns (uint256) {975		require(false, stub_error);976		dummy;977		return 0;978	}979}980981/// @dev inlined interface982contract ERC721Events {983	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);984	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);985	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);986}987988/// @title ERC-721 Non-Fungible Token Standard989/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md990/// @dev the ERC-165 identifier for this interface is 0x4016cd87991contract ERC721 is Dummy, ERC165, ERC721Events {992	/// @notice Count all RFTs assigned to an owner993	/// @dev RFTs assigned to the zero address are considered invalid, and this994	///  function throws for queries about the zero address.995	/// @param owner An address for whom to query the balance996	/// @return The number of RFTs owned by `owner`, possibly zero997	/// @dev EVM selector for this function is: 0x70a08231,998	///  or in textual repr: balanceOf(address)999	function balanceOf(address owner) public view returns (uint256) {1000		require(false, stub_error);1001		owner;1002		dummy;1003		return 0;1004	}10051006	/// @notice Find the owner of an RFT1007	/// @dev RFTs assigned to zero address are considered invalid, and queries1008	///  about them do throw.1009	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1010	///  the tokens that are partially owned.1011	/// @param tokenId The identifier for an RFT1012	/// @return The address of the owner of the RFT1013	/// @dev EVM selector for this function is: 0x6352211e,1014	///  or in textual repr: ownerOf(uint256)1015	function ownerOf(uint256 tokenId) public view returns (address) {1016		require(false, stub_error);1017		tokenId;1018		dummy;1019		return 0x0000000000000000000000000000000000000000;1020	}10211022	/// @dev Not implemented1023	/// @dev EVM selector for this function is: 0x60a11672,1024	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)1025	function safeTransferFromWithData(1026		address from,1027		address to,1028		uint256 tokenId,1029		bytes memory data1030	) public {1031		require(false, stub_error);1032		from;1033		to;1034		tokenId;1035		data;1036		dummy = 0;1037	}10381039	/// @dev Not implemented1040	/// @dev EVM selector for this function is: 0x42842e0e,1041	///  or in textual repr: safeTransferFrom(address,address,uint256)1042	function safeTransferFrom(1043		address from,1044		address to,1045		uint256 tokenId1046	) public {1047		require(false, stub_error);1048		from;1049		to;1050		tokenId;1051		dummy = 0;1052	}10531054	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1055	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1056	///  THEY MAY BE PERMANENTLY LOST1057	/// @dev Throws unless `msg.sender` is the current owner or an authorized1058	///  operator for this RFT. Throws if `from` is not the current owner. Throws1059	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1060	///  Throws if RFT pieces have multiple owners.1061	/// @param from The current owner of the NFT1062	/// @param to The new owner1063	/// @param tokenId The NFT to transfer1064	/// @dev EVM selector for this function is: 0x23b872dd,1065	///  or in textual repr: transferFrom(address,address,uint256)1066	function transferFrom(1067		address from,1068		address to,1069		uint256 tokenId1070	) public {1071		require(false, stub_error);1072		from;1073		to;1074		tokenId;1075		dummy = 0;1076	}10771078	/// @dev Not implemented1079	/// @dev EVM selector for this function is: 0x095ea7b3,1080	///  or in textual repr: approve(address,uint256)1081	function approve(address approved, uint256 tokenId) public {1082		require(false, stub_error);1083		approved;1084		tokenId;1085		dummy = 0;1086	}10871088	/// @notice Sets or unsets the approval of a given operator.1089	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1090	/// @param operator Operator1091	/// @param approved Should operator status be granted or revoked?1092	/// @dev EVM selector for this function is: 0xa22cb465,1093	///  or in textual repr: setApprovalForAll(address,bool)1094	function setApprovalForAll(address operator, bool approved) public {1095		require(false, stub_error);1096		operator;1097		approved;1098		dummy = 0;1099	}11001101	/// @dev Not implemented1102	/// @dev EVM selector for this function is: 0x081812fc,1103	///  or in textual repr: getApproved(uint256)1104	function getApproved(uint256 tokenId) public view returns (address) {1105		require(false, stub_error);1106		tokenId;1107		dummy;1108		return 0x0000000000000000000000000000000000000000;1109	}11101111	/// @notice Tells whether the given `owner` approves the `operator`.1112	/// @dev EVM selector for this function is: 0xe985e9c5,1113	///  or in textual repr: isApprovedForAll(address,address)1114	function isApprovedForAll(address owner, address operator) public view returns (bool) {1115		require(false, stub_error);1116		owner;1117		operator;1118		dummy;1119		return false;1120	}11211122	/// @notice Returns collection helper contract address1123	/// @dev EVM selector for this function is: 0x1896cce6,1124	///  or in textual repr: collectionHelperAddress()1125	function collectionHelperAddress() public view returns (address) {1126		require(false, stub_error);1127		dummy;1128		return 0x0000000000000000000000000000000000000000;1129	}1130}11311132contract UniqueRefungible is1133	Dummy,1134	ERC165,1135	ERC721,1136	ERC721Enumerable,1137	ERC721UniqueExtensions,1138	ERC721UniqueMintable,1139	ERC721Burnable,1140	ERC721Metadata,1141	Collection,1142	TokenProperties1143{}