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, Tuple20[] 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(Tuple20[] 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 (Tuple20[] memory) {177		require(false, stub_error);178		keys;179		dummy;180		return new Tuple20[](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 (Tuple23 memory) {243		require(false, stub_error);244		dummy;245		return Tuple23(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 Tuple23 {536	address field_0;537	uint256 field_1;538}539540/// @dev anonymous struct541struct Tuple20 {542	string field_0;543	bytes field_1;544}545546/// @dev the ERC-165 identifier for this interface is 0x5b5e139f547contract ERC721Metadata is Dummy, ERC165 {548	// /// @notice A descriptive name for a collection of NFTs in this contract549	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`550	// /// @dev EVM selector for this function is: 0x06fdde03,551	// ///  or in textual repr: name()552	// function name() public view returns (string memory) {553	// 	require(false, stub_error);554	// 	dummy;555	// 	return "";556	// }557558	// /// @notice An abbreviated name for NFTs in this contract559	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`560	// /// @dev EVM selector for this function is: 0x95d89b41,561	// ///  or in textual repr: symbol()562	// function symbol() public view returns (string memory) {563	// 	require(false, stub_error);564	// 	dummy;565	// 	return "";566	// }567568	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.569	///570	/// @dev If the token has a `url` property and it is not empty, it is returned.571	///  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`.572	///  If the collection property `baseURI` is empty or absent, return "" (empty string)573	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix574	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).575	///576	/// @return token's const_metadata577	/// @dev EVM selector for this function is: 0xc87b56dd,578	///  or in textual repr: tokenURI(uint256)579	function tokenURI(uint256 tokenId) public view returns (string memory) {580		require(false, stub_error);581		tokenId;582		dummy;583		return "";584	}585}586587/// @title ERC721 Token that can be irreversibly burned (destroyed).588/// @dev the ERC-165 identifier for this interface is 0x42966c68589contract ERC721Burnable is Dummy, ERC165 {590	/// @notice Burns a specific ERC721 token.591	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized592	///  operator of the current owner.593	/// @param tokenId The RFT to approve594	/// @dev EVM selector for this function is: 0x42966c68,595	///  or in textual repr: burn(uint256)596	function burn(uint256 tokenId) public {597		require(false, stub_error);598		tokenId;599		dummy = 0;600	}601}602603/// @dev inlined interface604contract ERC721UniqueMintableEvents {605	event MintingFinished();606}607608/// @title ERC721 minting logic.609/// @dev the ERC-165 identifier for this interface is 0x476ff149610contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {611	/// @dev EVM selector for this function is: 0x05d2035b,612	///  or in textual repr: mintingFinished()613	function mintingFinished() public view returns (bool) {614		require(false, stub_error);615		dummy;616		return false;617	}618619	/// @notice Function to mint token.620	/// @param to The new owner621	/// @return uint256 The id of the newly minted token622	/// @dev EVM selector for this function is: 0x6a627842,623	///  or in textual repr: mint(address)624	function mint(address to) public returns (uint256) {625		require(false, stub_error);626		to;627		dummy = 0;628		return 0;629	}630631	// /// @notice Function to mint token.632	// /// @dev `tokenId` should be obtained with `nextTokenId` method,633	// ///  unlike standard, you can't specify it manually634	// /// @param to The new owner635	// /// @param tokenId ID of the minted RFT636	// /// @dev EVM selector for this function is: 0x40c10f19,637	// ///  or in textual repr: mint(address,uint256)638	// function mint(address to, uint256 tokenId) public returns (bool) {639	// 	require(false, stub_error);640	// 	to;641	// 	tokenId;642	// 	dummy = 0;643	// 	return false;644	// }645646	/// @notice Function to mint token with the given tokenUri.647	/// @param to The new owner648	/// @param tokenUri Token URI that would be stored in the NFT properties649	/// @return uint256 The id of the newly minted token650	/// @dev EVM selector for this function is: 0x45c17782,651	///  or in textual repr: mintWithTokenURI(address,string)652	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {653		require(false, stub_error);654		to;655		tokenUri;656		dummy = 0;657		return 0;658	}659660	// /// @notice Function to mint token with the given tokenUri.661	// /// @dev `tokenId` should be obtained with `nextTokenId` method,662	// ///  unlike standard, you can't specify it manually663	// /// @param to The new owner664	// /// @param tokenId ID of the minted RFT665	// /// @param tokenUri Token URI that would be stored in the RFT properties666	// /// @dev EVM selector for this function is: 0x50bb4e7f,667	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)668	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {669	// 	require(false, stub_error);670	// 	to;671	// 	tokenId;672	// 	tokenUri;673	// 	dummy = 0;674	// 	return false;675	// }676677	/// @dev Not implemented678	/// @dev EVM selector for this function is: 0x7d64bcb4,679	///  or in textual repr: finishMinting()680	function finishMinting() public returns (bool) {681		require(false, stub_error);682		dummy = 0;683		return false;684	}685}686687/// @title Unique extensions for ERC721.688/// @dev the ERC-165 identifier for this interface is 0x81feb398689contract ERC721UniqueExtensions is Dummy, ERC165 {690	/// @notice A descriptive name for a collection of NFTs in this contract691	/// @dev EVM selector for this function is: 0x06fdde03,692	///  or in textual repr: name()693	function name() public view returns (string memory) {694		require(false, stub_error);695		dummy;696		return "";697	}698699	/// @notice An abbreviated name for NFTs in this contract700	/// @dev EVM selector for this function is: 0x95d89b41,701	///  or in textual repr: symbol()702	function symbol() public view returns (string memory) {703		require(false, stub_error);704		dummy;705		return "";706	}707708	/// @notice Transfer ownership of an RFT709	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`710	///  is the zero address. Throws if `tokenId` is not a valid RFT.711	///  Throws if RFT pieces have multiple owners.712	/// @param to The new owner713	/// @param tokenId The RFT to transfer714	/// @dev EVM selector for this function is: 0xa9059cbb,715	///  or in textual repr: transfer(address,uint256)716	function transfer(address to, uint256 tokenId) public {717		require(false, stub_error);718		to;719		tokenId;720		dummy = 0;721	}722723	/// @notice Transfer ownership of an RFT724	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`725	///  is the zero address. Throws if `tokenId` is not a valid RFT.726	///  Throws if RFT pieces have multiple owners.727	/// @param to The new owner728	/// @param tokenId The RFT to transfer729	/// @dev EVM selector for this function is: 0xd5cf430b,730	///  or in textual repr: transferFromCross(EthCrossAccount,EthCrossAccount,uint256)731	///  or in the expanded repr: transferFromCross((address,uint256),(address,uint256),uint256)732	function transferFromCross(733		EthCrossAccount memory from,734		EthCrossAccount memory to,735		uint256 tokenId736	) public {737		require(false, stub_error);738		from;739		to;740		tokenId;741		dummy = 0;742	}743744	/// @notice Burns a specific ERC721 token.745	/// @dev Throws unless `msg.sender` is the current owner or an authorized746	///  operator for this RFT. Throws if `from` is not the current owner. Throws747	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.748	///  Throws if RFT pieces have multiple owners.749	/// @param from The current owner of the RFT750	/// @param tokenId The RFT to transfer751	/// @dev EVM selector for this function is: 0x79cc6790,752	///  or in textual repr: burnFrom(address,uint256)753	function burnFrom(address from, uint256 tokenId) public {754		require(false, stub_error);755		from;756		tokenId;757		dummy = 0;758	}759760	/// @notice Burns a specific ERC721 token.761	/// @dev Throws unless `msg.sender` is the current owner or an authorized762	///  operator for this RFT. Throws if `from` is not the current owner. Throws763	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.764	///  Throws if RFT pieces have multiple owners.765	/// @param from The current owner of the RFT766	/// @param tokenId The RFT to transfer767	/// @dev EVM selector for this function is: 0xbb2f5a58,768	///  or in textual repr: burnFromCross(EthCrossAccount,uint256)769	///  or in the expanded repr: burnFromCross((address,uint256),uint256)770	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {771		require(false, stub_error);772		from;773		tokenId;774		dummy = 0;775	}776777	/// @notice Returns next free RFT ID.778	/// @dev EVM selector for this function is: 0x75794a3c,779	///  or in textual repr: nextTokenId()780	function nextTokenId() public view returns (uint256) {781		require(false, stub_error);782		dummy;783		return 0;784	}785786	// /// @notice Function to mint multiple tokens.787	// /// @dev `tokenIds` should be an array of consecutive numbers and first number788	// ///  should be obtained with `nextTokenId` method789	// /// @param to The new owner790	// /// @param tokenIds IDs of the minted RFTs791	// /// @dev EVM selector for this function is: 0x44a9945e,792	// ///  or in textual repr: mintBulk(address,uint256[])793	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {794	// 	require(false, stub_error);795	// 	to;796	// 	tokenIds;797	// 	dummy = 0;798	// 	return false;799	// }800801	// /// @notice Function to mint multiple tokens with the given tokenUris.802	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive803	// ///  numbers and first number should be obtained with `nextTokenId` method804	// /// @param to The new owner805	// /// @param tokens array of pairs of token ID and token URI for minted tokens806	// /// @dev EVM selector for this function is: 0x36543006,807	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])808	// function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) public returns (bool) {809	// 	require(false, stub_error);810	// 	to;811	// 	tokens;812	// 	dummy = 0;813	// 	return false;814	// }815816	/// Returns EVM address for refungible token817	///818	/// @param token ID of the token819	/// @dev EVM selector for this function is: 0xab76fac6,820	///  or in textual repr: tokenContractAddress(uint256)821	function tokenContractAddress(uint256 token) public view returns (address) {822		require(false, stub_error);823		token;824		dummy;825		return 0x0000000000000000000000000000000000000000;826	}827}828829/// @dev anonymous struct830struct Tuple9 {831	uint256 field_0;832	string field_1;833}834835/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension836/// @dev See https://eips.ethereum.org/EIPS/eip-721837/// @dev the ERC-165 identifier for this interface is 0x780e9d63838contract ERC721Enumerable is Dummy, ERC165 {839	/// @notice Enumerate valid RFTs840	/// @param index A counter less than `totalSupply()`841	/// @return The token identifier for the `index`th NFT,842	///  (sort order not specified)843	/// @dev EVM selector for this function is: 0x4f6ccce7,844	///  or in textual repr: tokenByIndex(uint256)845	function tokenByIndex(uint256 index) public view returns (uint256) {846		require(false, stub_error);847		index;848		dummy;849		return 0;850	}851852	/// Not implemented853	/// @dev EVM selector for this function is: 0x2f745c59,854	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)855	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {856		require(false, stub_error);857		owner;858		index;859		dummy;860		return 0;861	}862863	/// @notice Count RFTs tracked by this contract864	/// @return A count of valid RFTs tracked by this contract, where each one of865	///  them has an assigned and queryable owner not equal to the zero address866	/// @dev EVM selector for this function is: 0x18160ddd,867	///  or in textual repr: totalSupply()868	function totalSupply() public view returns (uint256) {869		require(false, stub_error);870		dummy;871		return 0;872	}873}874875/// @dev inlined interface876contract ERC721Events {877	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);878	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);879	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);880}881882/// @title ERC-721 Non-Fungible Token Standard883/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md884/// @dev the ERC-165 identifier for this interface is 0x58800161885contract ERC721 is Dummy, ERC165, ERC721Events {886	/// @notice Count all RFTs assigned to an owner887	/// @dev RFTs assigned to the zero address are considered invalid, and this888	///  function throws for queries about the zero address.889	/// @param owner An address for whom to query the balance890	/// @return The number of RFTs owned by `owner`, possibly zero891	/// @dev EVM selector for this function is: 0x70a08231,892	///  or in textual repr: balanceOf(address)893	function balanceOf(address owner) public view returns (uint256) {894		require(false, stub_error);895		owner;896		dummy;897		return 0;898	}899900	/// @notice Find the owner of an RFT901	/// @dev RFTs assigned to zero address are considered invalid, and queries902	///  about them do throw.903	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for904	///  the tokens that are partially owned.905	/// @param tokenId The identifier for an RFT906	/// @return The address of the owner of the RFT907	/// @dev EVM selector for this function is: 0x6352211e,908	///  or in textual repr: ownerOf(uint256)909	function ownerOf(uint256 tokenId) public view returns (address) {910		require(false, stub_error);911		tokenId;912		dummy;913		return 0x0000000000000000000000000000000000000000;914	}915916	/// @dev Not implemented917	/// @dev EVM selector for this function is: 0x60a11672,918	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)919	function safeTransferFromWithData(920		address from,921		address to,922		uint256 tokenId,923		bytes memory data924	) public {925		require(false, stub_error);926		from;927		to;928		tokenId;929		data;930		dummy = 0;931	}932933	/// @dev Not implemented934	/// @dev EVM selector for this function is: 0x42842e0e,935	///  or in textual repr: safeTransferFrom(address,address,uint256)936	function safeTransferFrom(937		address from,938		address to,939		uint256 tokenId940	) public {941		require(false, stub_error);942		from;943		to;944		tokenId;945		dummy = 0;946	}947948	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE949	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE950	///  THEY MAY BE PERMANENTLY LOST951	/// @dev Throws unless `msg.sender` is the current owner or an authorized952	///  operator for this RFT. Throws if `from` is not the current owner. Throws953	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.954	///  Throws if RFT pieces have multiple owners.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	/// @dev Not implemented973	/// @dev EVM selector for this function is: 0x095ea7b3,974	///  or in textual repr: approve(address,uint256)975	function approve(address approved, uint256 tokenId) public {976		require(false, stub_error);977		approved;978		tokenId;979		dummy = 0;980	}981982	/// @dev Not implemented983	/// @dev EVM selector for this function is: 0xa22cb465,984	///  or in textual repr: setApprovalForAll(address,bool)985	function setApprovalForAll(address operator, bool approved) public {986		require(false, stub_error);987		operator;988		approved;989		dummy = 0;990	}991992	/// @dev Not implemented993	/// @dev EVM selector for this function is: 0x081812fc,994	///  or in textual repr: getApproved(uint256)995	function getApproved(uint256 tokenId) public view returns (address) {996		require(false, stub_error);997		tokenId;998		dummy;999		return 0x0000000000000000000000000000000000000000;1000	}10011002	/// @dev Not implemented1003	/// @dev EVM selector for this function is: 0xe985e9c5,1004	///  or in textual repr: isApprovedForAll(address,address)1005	function isApprovedForAll(address owner, address operator) public view returns (address) {1006		require(false, stub_error);1007		owner;1008		operator;1009		dummy;1010		return 0x0000000000000000000000000000000000000000;1011	}1012}10131014contract UniqueRefungible is1015	Dummy,1016	ERC165,1017	ERC721,1018	ERC721Enumerable,1019	ERC721UniqueExtensions,1020	ERC721UniqueMintable,1021	ERC721Burnable,1022	ERC721Metadata,1023	Collection,1024	TokenProperties1025{}