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

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 0x81172a75156contract 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	/// Get current collection limits.296	///297	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:298	/// 	"accountTokenOwnershipLimit",299	/// 	"sponsoredDataSize",300	/// 	"sponsoredDataRateLimit",301	/// 	"tokenLimit",302	/// 	"sponsorTransferTimeout",303	/// 	"sponsorApproveTimeout"304	///  	"ownerCanTransfer",305	/// 	"ownerCanDestroy",306	/// 	"transfersEnabled"307	/// Return `false` if a limit not set.308	/// @dev EVM selector for this function is: 0xf63bc572,309	///  or in textual repr: collectionLimits()310	function collectionLimits() public view returns (Tuple32[] memory) {311		require(false, stub_error);312		dummy;313		return new Tuple32[](0);314	}315316	/// Set limits for the collection.317	/// @dev Throws error if limit not found.318	/// @param limit Name of the limit. Valid names:319	/// 	"accountTokenOwnershipLimit",320	/// 	"sponsoredDataSize",321	/// 	"sponsoredDataRateLimit",322	/// 	"tokenLimit",323	/// 	"sponsorTransferTimeout",324	/// 	"sponsorApproveTimeout"325	///  	"ownerCanTransfer",326	/// 	"ownerCanDestroy",327	/// 	"transfersEnabled"328	/// @param status enable\disable limit. Works only with `true`.329	/// @param value Value of the limit.330	/// @dev EVM selector for this function is: 0x88150bd0,331	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)332	function setCollectionLimit(333		CollectionLimits limit,334		bool status,335		uint256 value336	) public {337		require(false, stub_error);338		limit;339		status;340		value;341		dummy = 0;342	}343344	/// Get contract address.345	/// @dev EVM selector for this function is: 0xf6b4dfb4,346	///  or in textual repr: contractAddress()347	function contractAddress() public view returns (address) {348		require(false, stub_error);349		dummy;350		return 0x0000000000000000000000000000000000000000;351	}352353	/// Add collection admin.354	/// @param newAdmin Cross account administrator address.355	/// @dev EVM selector for this function is: 0x859aa7d6,356	///  or in textual repr: addCollectionAdminCross((address,uint256))357	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {358		require(false, stub_error);359		newAdmin;360		dummy = 0;361	}362363	/// Remove collection admin.364	/// @param admin Cross account administrator address.365	/// @dev EVM selector for this function is: 0x6c0cd173,366	///  or in textual repr: removeCollectionAdminCross((address,uint256))367	function removeCollectionAdminCross(EthCrossAccount memory admin) public {368		require(false, stub_error);369		admin;370		dummy = 0;371	}372373	// /// Add collection admin.374	// /// @param newAdmin Address of the added administrator.375	// /// @dev EVM selector for this function is: 0x92e462c7,376	// ///  or in textual repr: addCollectionAdmin(address)377	// function addCollectionAdmin(address newAdmin) public {378	// 	require(false, stub_error);379	// 	newAdmin;380	// 	dummy = 0;381	// }382383	// /// Remove collection admin.384	// ///385	// /// @param admin Address of the removed administrator.386	// /// @dev EVM selector for this function is: 0xfafd7b42,387	// ///  or in textual repr: removeCollectionAdmin(address)388	// function removeCollectionAdmin(address admin) public {389	// 	require(false, stub_error);390	// 	admin;391	// 	dummy = 0;392	// }393394	/// Toggle accessibility of collection nesting.395	///396	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'397	/// @dev EVM selector for this function is: 0x112d4586,398	///  or in textual repr: setCollectionNesting(bool)399	function setCollectionNesting(bool enable) public {400		require(false, stub_error);401		enable;402		dummy = 0;403	}404405	/// Toggle accessibility of collection nesting.406	///407	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'408	/// @param collections Addresses of collections that will be available for nesting.409	/// @dev EVM selector for this function is: 0x64872396,410	///  or in textual repr: setCollectionNesting(bool,address[])411	function setCollectionNesting(bool enable, address[] memory collections) public {412		require(false, stub_error);413		enable;414		collections;415		dummy = 0;416	}417418	/// Returns nesting for a collection419	/// @dev EVM selector for this function is: 0x22d25bfe,420	///  or in textual repr: collectionNestingRestrictedCollectionIds()421	function collectionNestingRestrictedCollectionIds() public view returns (Tuple38 memory) {422		require(false, stub_error);423		dummy;424		return Tuple38(false, new uint256[](0));425	}426427	/// Returns permissions for a collection428	/// @dev EVM selector for this function is: 0x5b2eaf4b,429	///  or in textual repr: collectionNestingPermissions()430	function collectionNestingPermissions() public view returns (Tuple41[] memory) {431		require(false, stub_error);432		dummy;433		return new Tuple41[](0);434	}435436	/// Set the collection access method.437	/// @param mode Access mode438	/// 	0 for Normal439	/// 	1 for AllowList440	/// @dev EVM selector for this function is: 0x41835d4c,441	///  or in textual repr: setCollectionAccess(uint8)442	function setCollectionAccess(uint8 mode) public {443		require(false, stub_error);444		mode;445		dummy = 0;446	}447448	/// Checks that user allowed to operate with collection.449	///450	/// @param user User address to check.451	/// @dev EVM selector for this function is: 0x91b6df49,452	///  or in textual repr: allowlistedCross((address,uint256))453	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {454		require(false, stub_error);455		user;456		dummy;457		return false;458	}459460	// /// Add the user to the allowed list.461	// ///462	// /// @param user Address of a trusted user.463	// /// @dev EVM selector for this function is: 0x67844fe6,464	// ///  or in textual repr: addToCollectionAllowList(address)465	// function addToCollectionAllowList(address user) public {466	// 	require(false, stub_error);467	// 	user;468	// 	dummy = 0;469	// }470471	/// Add user to allowed list.472	///473	/// @param user User cross account address.474	/// @dev EVM selector for this function is: 0xa0184a3a,475	///  or in textual repr: addToCollectionAllowListCross((address,uint256))476	function addToCollectionAllowListCross(EthCrossAccount memory user) public {477		require(false, stub_error);478		user;479		dummy = 0;480	}481482	// /// Remove the user from the allowed list.483	// ///484	// /// @param user Address of a removed user.485	// /// @dev EVM selector for this function is: 0x85c51acb,486	// ///  or in textual repr: removeFromCollectionAllowList(address)487	// function removeFromCollectionAllowList(address user) public {488	// 	require(false, stub_error);489	// 	user;490	// 	dummy = 0;491	// }492493	/// Remove user from allowed list.494	///495	/// @param user User cross account address.496	/// @dev EVM selector for this function is: 0x09ba452a,497	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))498	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {499		require(false, stub_error);500		user;501		dummy = 0;502	}503504	/// Switch permission for minting.505	///506	/// @param mode Enable if "true".507	/// @dev EVM selector for this function is: 0x00018e84,508	///  or in textual repr: setCollectionMintMode(bool)509	function setCollectionMintMode(bool mode) public {510		require(false, stub_error);511		mode;512		dummy = 0;513	}514515	// /// Check that account is the owner or admin of the collection516	// ///517	// /// @param user account to verify518	// /// @return "true" if account is the owner or admin519	// /// @dev EVM selector for this function is: 0x9811b0c7,520	// ///  or in textual repr: isOwnerOrAdmin(address)521	// function isOwnerOrAdmin(address user) public view returns (bool) {522	// 	require(false, stub_error);523	// 	user;524	// 	dummy;525	// 	return false;526	// }527528	/// Check that account is the owner or admin of the collection529	///530	/// @param user User cross account to verify531	/// @return "true" if account is the owner or admin532	/// @dev EVM selector for this function is: 0x3e75a905,533	///  or in textual repr: isOwnerOrAdminCross((address,uint256))534	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {535		require(false, stub_error);536		user;537		dummy;538		return false;539	}540541	/// Returns collection type542	///543	/// @return `Fungible` or `NFT` or `ReFungible`544	/// @dev EVM selector for this function is: 0xd34b55b8,545	///  or in textual repr: uniqueCollectionType()546	function uniqueCollectionType() public view returns (string memory) {547		require(false, stub_error);548		dummy;549		return "";550	}551552	/// Get collection owner.553	///554	/// @return Tuble with sponsor address and his substrate mirror.555	/// If address is canonical then substrate mirror is zero and vice versa.556	/// @dev EVM selector for this function is: 0xdf727d3b,557	///  or in textual repr: collectionOwner()558	function collectionOwner() public view returns (EthCrossAccount memory) {559		require(false, stub_error);560		dummy;561		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);562	}563564	// /// Changes collection owner to another account565	// ///566	// /// @dev Owner can be changed only by current owner567	// /// @param newOwner new owner account568	// /// @dev EVM selector for this function is: 0x4f53e226,569	// ///  or in textual repr: changeCollectionOwner(address)570	// function changeCollectionOwner(address newOwner) public {571	// 	require(false, stub_error);572	// 	newOwner;573	// 	dummy = 0;574	// }575576	/// Get collection administrators577	///578	/// @return Vector of tuples with admins address and his substrate mirror.579	/// If address is canonical then substrate mirror is zero and vice versa.580	/// @dev EVM selector for this function is: 0x5813216b,581	///  or in textual repr: collectionAdmins()582	function collectionAdmins() public view returns (EthCrossAccount[] memory) {583		require(false, stub_error);584		dummy;585		return new EthCrossAccount[](0);586	}587588	/// Changes collection owner to another account589	///590	/// @dev Owner can be changed only by current owner591	/// @param newOwner new owner cross account592	/// @dev EVM selector for this function is: 0x6496c497,593	///  or in textual repr: changeCollectionOwnerCross((address,uint256))594	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {595		require(false, stub_error);596		newOwner;597		dummy = 0;598	}599}600601/// @dev Cross account struct602struct EthCrossAccount {603	address eth;604	uint256 sub;605}606607enum CollectionPermissions {608	CollectionAdmin,609	TokenOwner610}611612/// @dev anonymous struct613struct Tuple41 {614	CollectionPermissions field_0;615	bool field_1;616}617618/// @dev anonymous struct619struct Tuple38 {620	bool field_0;621	uint256[] field_1;622}623624enum CollectionLimits {625	AccountTokenOwnership,626	SponsoredDataSize,627	SponsoredDataRateLimit,628	TokenLimit,629	SponsorTransferTimeout,630	SponsorApproveTimeout,631	OwnerCanTransfer,632	OwnerCanDestroy,633	TransferEnabled634}635636/// @dev anonymous struct637struct Tuple32 {638	CollectionLimits field_0;639	bool field_1;640	uint256 field_2;641}642643/// @dev anonymous struct644struct Tuple29 {645	address field_0;646	uint256 field_1;647}648649/// @dev the ERC-165 identifier for this interface is 0x5b5e139f650contract ERC721Metadata is Dummy, ERC165 {651	// /// @notice A descriptive name for a collection of NFTs in this contract652	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`653	// /// @dev EVM selector for this function is: 0x06fdde03,654	// ///  or in textual repr: name()655	// function name() public view returns (string memory) {656	// 	require(false, stub_error);657	// 	dummy;658	// 	return "";659	// }660661	// /// @notice An abbreviated name for NFTs in this contract662	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`663	// /// @dev EVM selector for this function is: 0x95d89b41,664	// ///  or in textual repr: symbol()665	// function symbol() public view returns (string memory) {666	// 	require(false, stub_error);667	// 	dummy;668	// 	return "";669	// }670671	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.672	///673	/// @dev If the token has a `url` property and it is not empty, it is returned.674	///  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`.675	///  If the collection property `baseURI` is empty or absent, return "" (empty string)676	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix677	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).678	///679	/// @return token's const_metadata680	/// @dev EVM selector for this function is: 0xc87b56dd,681	///  or in textual repr: tokenURI(uint256)682	function tokenURI(uint256 tokenId) public view returns (string memory) {683		require(false, stub_error);684		tokenId;685		dummy;686		return "";687	}688}689690/// @title ERC721 Token that can be irreversibly burned (destroyed).691/// @dev the ERC-165 identifier for this interface is 0x42966c68692contract ERC721Burnable is Dummy, ERC165 {693	/// @notice Burns a specific ERC721 token.694	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized695	///  operator of the current owner.696	/// @param tokenId The RFT to approve697	/// @dev EVM selector for this function is: 0x42966c68,698	///  or in textual repr: burn(uint256)699	function burn(uint256 tokenId) public {700		require(false, stub_error);701		tokenId;702		dummy = 0;703	}704}705706/// @dev inlined interface707contract ERC721UniqueMintableEvents {708	event MintingFinished();709}710711/// @title ERC721 minting logic.712/// @dev the ERC-165 identifier for this interface is 0x476ff149713contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {714	/// @dev EVM selector for this function is: 0x05d2035b,715	///  or in textual repr: mintingFinished()716	function mintingFinished() public view returns (bool) {717		require(false, stub_error);718		dummy;719		return false;720	}721722	/// @notice Function to mint token.723	/// @param to The new owner724	/// @return uint256 The id of the newly minted token725	/// @dev EVM selector for this function is: 0x6a627842,726	///  or in textual repr: mint(address)727	function mint(address to) public returns (uint256) {728		require(false, stub_error);729		to;730		dummy = 0;731		return 0;732	}733734	// /// @notice Function to mint token.735	// /// @dev `tokenId` should be obtained with `nextTokenId` method,736	// ///  unlike standard, you can't specify it manually737	// /// @param to The new owner738	// /// @param tokenId ID of the minted RFT739	// /// @dev EVM selector for this function is: 0x40c10f19,740	// ///  or in textual repr: mint(address,uint256)741	// function mint(address to, uint256 tokenId) public returns (bool) {742	// 	require(false, stub_error);743	// 	to;744	// 	tokenId;745	// 	dummy = 0;746	// 	return false;747	// }748749	/// @notice Function to mint token with the given tokenUri.750	/// @param to The new owner751	/// @param tokenUri Token URI that would be stored in the NFT properties752	/// @return uint256 The id of the newly minted token753	/// @dev EVM selector for this function is: 0x45c17782,754	///  or in textual repr: mintWithTokenURI(address,string)755	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {756		require(false, stub_error);757		to;758		tokenUri;759		dummy = 0;760		return 0;761	}762763	// /// @notice Function to mint token with the given tokenUri.764	// /// @dev `tokenId` should be obtained with `nextTokenId` method,765	// ///  unlike standard, you can't specify it manually766	// /// @param to The new owner767	// /// @param tokenId ID of the minted RFT768	// /// @param tokenUri Token URI that would be stored in the RFT properties769	// /// @dev EVM selector for this function is: 0x50bb4e7f,770	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)771	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {772	// 	require(false, stub_error);773	// 	to;774	// 	tokenId;775	// 	tokenUri;776	// 	dummy = 0;777	// 	return false;778	// }779780	/// @dev Not implemented781	/// @dev EVM selector for this function is: 0x7d64bcb4,782	///  or in textual repr: finishMinting()783	function finishMinting() public returns (bool) {784		require(false, stub_error);785		dummy = 0;786		return false;787	}788}789790/// @title Unique extensions for ERC721.791/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1792contract ERC721UniqueExtensions is Dummy, ERC165 {793	/// @notice A descriptive name for a collection of NFTs in this contract794	/// @dev EVM selector for this function is: 0x06fdde03,795	///  or in textual repr: name()796	function name() public view returns (string memory) {797		require(false, stub_error);798		dummy;799		return "";800	}801802	/// @notice An abbreviated name for NFTs in this contract803	/// @dev EVM selector for this function is: 0x95d89b41,804	///  or in textual repr: symbol()805	function symbol() public view returns (string memory) {806		require(false, stub_error);807		dummy;808		return "";809	}810811	/// @notice A description for the collection.812	/// @dev EVM selector for this function is: 0x7284e416,813	///  or in textual repr: description()814	function description() public view returns (string memory) {815		require(false, stub_error);816		dummy;817		return "";818	}819820	/// Returns the owner (in cross format) of the token.821	///822	/// @param tokenId Id for the token.823	/// @dev EVM selector for this function is: 0x2b29dace,824	///  or in textual repr: crossOwnerOf(uint256)825	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {826		require(false, stub_error);827		tokenId;828		dummy;829		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);830	}831832	/// Returns the token properties.833	///834	/// @param tokenId Id for the token.835	/// @param keys Properties keys. Empty keys for all propertyes.836	/// @return Vector of properties key/value pairs.837	/// @dev EVM selector for this function is: 0xe07ede7e,838	///  or in textual repr: properties(uint256,string[])839	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {840		require(false, stub_error);841		tokenId;842		keys;843		dummy;844		return new Property[](0);845	}846847	/// @notice Transfer ownership of an RFT848	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`849	///  is the zero address. Throws if `tokenId` is not a valid RFT.850	///  Throws if RFT pieces have multiple owners.851	/// @param to The new owner852	/// @param tokenId The RFT to transfer853	/// @dev EVM selector for this function is: 0xa9059cbb,854	///  or in textual repr: transfer(address,uint256)855	function transfer(address to, uint256 tokenId) public {856		require(false, stub_error);857		to;858		tokenId;859		dummy = 0;860	}861862	/// @notice Transfer ownership of an RFT863	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`864	///  is the zero address. Throws if `tokenId` is not a valid RFT.865	///  Throws if RFT pieces have multiple owners.866	/// @param to The new owner867	/// @param tokenId The RFT to transfer868	/// @dev EVM selector for this function is: 0x2ada85ff,869	///  or in textual repr: transferCross((address,uint256),uint256)870	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {871		require(false, stub_error);872		to;873		tokenId;874		dummy = 0;875	}876877	/// @notice Transfer ownership of an RFT878	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`879	///  is the zero address. Throws if `tokenId` is not a valid RFT.880	///  Throws if RFT pieces have multiple owners.881	/// @param to The new owner882	/// @param tokenId The RFT to transfer883	/// @dev EVM selector for this function is: 0xd5cf430b,884	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)885	function transferFromCross(886		EthCrossAccount memory from,887		EthCrossAccount memory to,888		uint256 tokenId889	) public {890		require(false, stub_error);891		from;892		to;893		tokenId;894		dummy = 0;895	}896897	// /// @notice Burns a specific ERC721 token.898	// /// @dev Throws unless `msg.sender` is the current owner or an authorized899	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws900	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.901	// ///  Throws if RFT pieces have multiple owners.902	// /// @param from The current owner of the RFT903	// /// @param tokenId The RFT to transfer904	// /// @dev EVM selector for this function is: 0x79cc6790,905	// ///  or in textual repr: burnFrom(address,uint256)906	// function burnFrom(address from, uint256 tokenId) public {907	// 	require(false, stub_error);908	// 	from;909	// 	tokenId;910	// 	dummy = 0;911	// }912913	/// @notice Burns a specific ERC721 token.914	/// @dev Throws unless `msg.sender` is the current owner or an authorized915	///  operator for this RFT. Throws if `from` is not the current owner. Throws916	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.917	///  Throws if RFT pieces have multiple owners.918	/// @param from The current owner of the RFT919	/// @param tokenId The RFT to transfer920	/// @dev EVM selector for this function is: 0xbb2f5a58,921	///  or in textual repr: burnFromCross((address,uint256),uint256)922	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {923		require(false, stub_error);924		from;925		tokenId;926		dummy = 0;927	}928929	/// @notice Returns next free RFT ID.930	/// @dev EVM selector for this function is: 0x75794a3c,931	///  or in textual repr: nextTokenId()932	function nextTokenId() public view returns (uint256) {933		require(false, stub_error);934		dummy;935		return 0;936	}937938	// /// @notice Function to mint multiple tokens.939	// /// @dev `tokenIds` should be an array of consecutive numbers and first number940	// ///  should be obtained with `nextTokenId` method941	// /// @param to The new owner942	// /// @param tokenIds IDs of the minted RFTs943	// /// @dev EVM selector for this function is: 0x44a9945e,944	// ///  or in textual repr: mintBulk(address,uint256[])945	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {946	// 	require(false, stub_error);947	// 	to;948	// 	tokenIds;949	// 	dummy = 0;950	// 	return false;951	// }952953	// /// @notice Function to mint multiple tokens with the given tokenUris.954	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive955	// ///  numbers and first number should be obtained with `nextTokenId` method956	// /// @param to The new owner957	// /// @param tokens array of pairs of token ID and token URI for minted tokens958	// /// @dev EVM selector for this function is: 0x36543006,959	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])960	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {961	// 	require(false, stub_error);962	// 	to;963	// 	tokens;964	// 	dummy = 0;965	// 	return false;966	// }967968	/// Returns EVM address for refungible token969	///970	/// @param token ID of the token971	/// @dev EVM selector for this function is: 0xab76fac6,972	///  or in textual repr: tokenContractAddress(uint256)973	function tokenContractAddress(uint256 token) public view returns (address) {974		require(false, stub_error);975		token;976		dummy;977		return 0x0000000000000000000000000000000000000000;978	}979}980981/// @dev anonymous struct982struct Tuple14 {983	uint256 field_0;984	string field_1;985}986987/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension988/// @dev See https://eips.ethereum.org/EIPS/eip-721989/// @dev the ERC-165 identifier for this interface is 0x780e9d63990contract ERC721Enumerable is Dummy, ERC165 {991	/// @notice Enumerate valid RFTs992	/// @param index A counter less than `totalSupply()`993	/// @return The token identifier for the `index`th NFT,994	///  (sort order not specified)995	/// @dev EVM selector for this function is: 0x4f6ccce7,996	///  or in textual repr: tokenByIndex(uint256)997	function tokenByIndex(uint256 index) public view returns (uint256) {998		require(false, stub_error);999		index;1000		dummy;1001		return 0;1002	}10031004	/// Not implemented1005	/// @dev EVM selector for this function is: 0x2f745c59,1006	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1007	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1008		require(false, stub_error);1009		owner;1010		index;1011		dummy;1012		return 0;1013	}10141015	/// @notice Count RFTs tracked by this contract1016	/// @return A count of valid RFTs tracked by this contract, where each one of1017	///  them has an assigned and queryable owner not equal to the zero address1018	/// @dev EVM selector for this function is: 0x18160ddd,1019	///  or in textual repr: totalSupply()1020	function totalSupply() public view returns (uint256) {1021		require(false, stub_error);1022		dummy;1023		return 0;1024	}1025}10261027/// @dev inlined interface1028contract ERC721Events {1029	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1030	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1031	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1032}10331034/// @title ERC-721 Non-Fungible Token Standard1035/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1036/// @dev the ERC-165 identifier for this interface is 0x4016cd871037contract ERC721 is Dummy, ERC165, ERC721Events {1038	/// @notice Count all RFTs assigned to an owner1039	/// @dev RFTs assigned to the zero address are considered invalid, and this1040	///  function throws for queries about the zero address.1041	/// @param owner An address for whom to query the balance1042	/// @return The number of RFTs owned by `owner`, possibly zero1043	/// @dev EVM selector for this function is: 0x70a08231,1044	///  or in textual repr: balanceOf(address)1045	function balanceOf(address owner) public view returns (uint256) {1046		require(false, stub_error);1047		owner;1048		dummy;1049		return 0;1050	}10511052	/// @notice Find the owner of an RFT1053	/// @dev RFTs assigned to zero address are considered invalid, and queries1054	///  about them do throw.1055	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1056	///  the tokens that are partially owned.1057	/// @param tokenId The identifier for an RFT1058	/// @return The address of the owner of the RFT1059	/// @dev EVM selector for this function is: 0x6352211e,1060	///  or in textual repr: ownerOf(uint256)1061	function ownerOf(uint256 tokenId) public view returns (address) {1062		require(false, stub_error);1063		tokenId;1064		dummy;1065		return 0x0000000000000000000000000000000000000000;1066	}10671068	/// @dev Not implemented1069	/// @dev EVM selector for this function is: 0x60a11672,1070	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)1071	function safeTransferFromWithData(1072		address from,1073		address to,1074		uint256 tokenId,1075		bytes memory data1076	) public {1077		require(false, stub_error);1078		from;1079		to;1080		tokenId;1081		data;1082		dummy = 0;1083	}10841085	/// @dev Not implemented1086	/// @dev EVM selector for this function is: 0x42842e0e,1087	///  or in textual repr: safeTransferFrom(address,address,uint256)1088	function safeTransferFrom(1089		address from,1090		address to,1091		uint256 tokenId1092	) public {1093		require(false, stub_error);1094		from;1095		to;1096		tokenId;1097		dummy = 0;1098	}10991100	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1101	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1102	///  THEY MAY BE PERMANENTLY LOST1103	/// @dev Throws unless `msg.sender` is the current owner or an authorized1104	///  operator for this RFT. Throws if `from` is not the current owner. Throws1105	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1106	///  Throws if RFT pieces have multiple owners.1107	/// @param from The current owner of the NFT1108	/// @param to The new owner1109	/// @param tokenId The NFT to transfer1110	/// @dev EVM selector for this function is: 0x23b872dd,1111	///  or in textual repr: transferFrom(address,address,uint256)1112	function transferFrom(1113		address from,1114		address to,1115		uint256 tokenId1116	) public {1117		require(false, stub_error);1118		from;1119		to;1120		tokenId;1121		dummy = 0;1122	}11231124	/// @dev Not implemented1125	/// @dev EVM selector for this function is: 0x095ea7b3,1126	///  or in textual repr: approve(address,uint256)1127	function approve(address approved, uint256 tokenId) public {1128		require(false, stub_error);1129		approved;1130		tokenId;1131		dummy = 0;1132	}11331134	/// @notice Sets or unsets the approval of a given operator.1135	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1136	/// @param operator Operator1137	/// @param approved Should operator status be granted or revoked?1138	/// @dev EVM selector for this function is: 0xa22cb465,1139	///  or in textual repr: setApprovalForAll(address,bool)1140	function setApprovalForAll(address operator, bool approved) public {1141		require(false, stub_error);1142		operator;1143		approved;1144		dummy = 0;1145	}11461147	/// @dev Not implemented1148	/// @dev EVM selector for this function is: 0x081812fc,1149	///  or in textual repr: getApproved(uint256)1150	function getApproved(uint256 tokenId) public view returns (address) {1151		require(false, stub_error);1152		tokenId;1153		dummy;1154		return 0x0000000000000000000000000000000000000000;1155	}11561157	/// @notice Tells whether the given `owner` approves the `operator`.1158	/// @dev EVM selector for this function is: 0xe985e9c5,1159	///  or in textual repr: isApprovedForAll(address,address)1160	function isApprovedForAll(address owner, address operator) public view returns (bool) {1161		require(false, stub_error);1162		owner;1163		operator;1164		dummy;1165		return false;1166	}11671168	/// @notice Returns collection helper contract address1169	/// @dev EVM selector for this function is: 0x1896cce6,1170	///  or in textual repr: collectionHelperAddress()1171	function collectionHelperAddress() public view returns (address) {1172		require(false, stub_error);1173		dummy;1174		return 0x0000000000000000000000000000000000000000;1175	}1176}11771178contract UniqueRefungible is1179	Dummy,1180	ERC165,1181	ERC721,1182	ERC721Enumerable,1183	ERC721UniqueExtensions,1184	ERC721UniqueMintable,1185	ERC721Burnable,1186	ERC721Metadata,1187	Collection,1188	TokenProperties1189{}