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

1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8	uint8 dummy;9	string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13	function supportsInterface(bytes4 interfaceID) external view returns (bool) {14		require(false, stub_error);15		interfaceID;16		return true;17	}18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0x91a97a6822contract TokenProperties is Dummy, ERC165 {23	/// @notice Set permissions for token property.24	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.25	/// @param key Property key.26	/// @param isMutable Permission to mutate property.27	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.29	/// @dev EVM selector for this function is: 0x222d97fa,30	///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31	function setTokenPropertyPermission(32		string memory key,33		bool isMutable,34		bool collectionAdmin,35		bool tokenOwner36	) public {37		require(false, stub_error);38		key;39		isMutable;40		collectionAdmin;41		tokenOwner;42		dummy = 0;43	}4445	// /// @notice Set token property value.46	// /// @dev Throws error if `msg.sender` has no permission to edit the property.47	// /// @param tokenId ID of the token.48	// /// @param key Property key.49	// /// @param value Property value.50	// /// @dev EVM selector for this function is: 0x1752d67b,51	// ///  or in textual repr: setProperty(uint256,string,bytes)52	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {53	// 	require(false, stub_error);54	// 	tokenId;55	// 	key;56	// 	value;57	// 	dummy = 0;58	// }5960	/// @notice Set token properties value.61	/// @dev Throws error if `msg.sender` has no permission to edit the property.62	/// @param tokenId ID of the token.63	/// @param properties settable properties64	/// @dev EVM selector for this function is: 0x14ed3a6e,65	///  or in textual repr: setProperties(uint256,(string,bytes)[])66	function setProperties(uint256 tokenId, Property[] memory properties) public {67		require(false, stub_error);68		tokenId;69		properties;70		dummy = 0;71	}7273	// /// @notice Delete token property value.74	// /// @dev Throws error if `msg.sender` has no permission to edit the property.75	// /// @param tokenId ID of the token.76	// /// @param key Property key.77	// /// @dev EVM selector for this function is: 0x066111d1,78	// ///  or in textual repr: deleteProperty(uint256,string)79	// function deleteProperty(uint256 tokenId, string memory key) public {80	// 	require(false, stub_error);81	// 	tokenId;82	// 	key;83	// 	dummy = 0;84	// }8586	/// @notice Delete token properties value.87	/// @dev Throws error if `msg.sender` has no permission to edit the property.88	/// @param tokenId ID of the token.89	/// @param keys Properties key.90	/// @dev EVM selector for this function is: 0xc472d371,91	///  or in textual repr: deleteProperties(uint256,string[])92	function deleteProperties(uint256 tokenId, string[] memory keys) public {93		require(false, stub_error);94		tokenId;95		keys;96		dummy = 0;97	}9899	/// @notice Get token property value.100	/// @dev Throws error if key not found101	/// @param tokenId ID of the token.102	/// @param key Property key.103	/// @return Property value bytes104	/// @dev EVM selector for this function is: 0x7228c327,105	///  or in textual repr: property(uint256,string)106	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107		require(false, stub_error);108		tokenId;109		key;110		dummy;111		return hex"";112	}113}114115/// @dev Property struct116struct Property {117	string key;118	bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0xb5e1747f123contract Collection is Dummy, ERC165 {124	// /// Set collection property.125	// ///126	// /// @param key Property key.127	// /// @param value Propery value.128	// /// @dev EVM selector for this function is: 0x2f073f66,129	// ///  or in textual repr: setCollectionProperty(string,bytes)130	// function setCollectionProperty(string memory key, bytes memory value) public {131	// 	require(false, stub_error);132	// 	key;133	// 	value;134	// 	dummy = 0;135	// }136137	/// Set collection properties.138	///139	/// @param properties Vector of properties key/value pair.140	/// @dev EVM selector for this function is: 0x50b26b2a,141	///  or in textual repr: setCollectionProperties((string,bytes)[])142	function setCollectionProperties(Property[] memory properties) public {143		require(false, stub_error);144		properties;145		dummy = 0;146	}147148	// /// Delete collection property.149	// ///150	// /// @param key Property key.151	// /// @dev EVM selector for this function is: 0x7b7debce,152	// ///  or in textual repr: deleteCollectionProperty(string)153	// function deleteCollectionProperty(string memory key) public {154	// 	require(false, stub_error);155	// 	key;156	// 	dummy = 0;157	// }158159	/// Delete collection properties.160	///161	/// @param keys Properties keys.162	/// @dev EVM selector for this function is: 0xee206ee3,163	///  or in textual repr: deleteCollectionProperties(string[])164	function deleteCollectionProperties(string[] memory keys) public {165		require(false, stub_error);166		keys;167		dummy = 0;168	}169170	/// Get collection property.171	///172	/// @dev Throws error if key not found.173	///174	/// @param key Property key.175	/// @return bytes The property corresponding to the key.176	/// @dev EVM selector for this function is: 0xcf24fd6d,177	///  or in textual repr: collectionProperty(string)178	function collectionProperty(string memory key) public view returns (bytes memory) {179		require(false, stub_error);180		key;181		dummy;182		return hex"";183	}184185	/// Get collection properties.186	///187	/// @param keys Properties keys. Empty keys for all propertyes.188	/// @return Vector of properties key/value pairs.189	/// @dev EVM selector for this function is: 0x285fb8e6,190	///  or in textual repr: collectionProperties(string[])191	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {192		require(false, stub_error);193		keys;194		dummy;195		return new Property[](0);196	}197198	// /// Set the sponsor of the collection.199	// ///200	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201	// ///202	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203	// /// @dev EVM selector for this function is: 0x7623402e,204	// ///  or in textual repr: setCollectionSponsor(address)205	// function setCollectionSponsor(address sponsor) public {206	// 	require(false, stub_error);207	// 	sponsor;208	// 	dummy = 0;209	// }210211	/// Set the sponsor of the collection.212	///213	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214	///215	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216	/// @dev EVM selector for this function is: 0x84a1d5a8,217	///  or in textual repr: setCollectionSponsorCross((address,uint256))218	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219		require(false, stub_error);220		sponsor;221		dummy = 0;222	}223224	/// Whether there is a pending sponsor.225	/// @dev EVM selector for this function is: 0x058ac185,226	///  or in textual repr: hasCollectionPendingSponsor()227	function hasCollectionPendingSponsor() public view returns (bool) {228		require(false, stub_error);229		dummy;230		return false;231	}232233	/// Collection sponsorship confirmation.234	///235	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.236	/// @dev EVM selector for this function is: 0x3c50e97a,237	///  or in textual repr: confirmCollectionSponsorship()238	function confirmCollectionSponsorship() public {239		require(false, stub_error);240		dummy = 0;241	}242243	/// Remove collection sponsor.244	/// @dev EVM selector for this function is: 0x6e0326a3,245	///  or in textual repr: removeCollectionSponsor()246	function removeCollectionSponsor() public {247		require(false, stub_error);248		dummy = 0;249	}250251	/// Get current sponsor.252	///253	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254	/// @dev EVM selector for this function is: 0x6ec0a9f1,255	///  or in textual repr: collectionSponsor()256	function collectionSponsor() public view returns (Tuple29 memory) {257		require(false, stub_error);258		dummy;259		return Tuple29(0x0000000000000000000000000000000000000000, 0);260	}261262	/// Set limits for the collection.263	/// @dev Throws error if limit not found.264	/// @param limit Name of the limit. Valid names:265	/// 	"accountTokenOwnershipLimit",266	/// 	"sponsoredDataSize",267	/// 	"sponsoredDataRateLimit",268	/// 	"tokenLimit",269	/// 	"sponsorTransferTimeout",270	/// 	"sponsorApproveTimeout"271	///  	"ownerCanTransfer",272	/// 	"ownerCanDestroy",273	/// 	"transfersEnabled"274	/// @param value Value of the limit.275	/// @dev EVM selector for this function is: 0x4ad890a8,276	///  or in textual repr: setCollectionLimit(string,uint256)277	function setCollectionLimit(string memory limit, uint256 value) public {278		require(false, stub_error);279		limit;280		value;281		dummy = 0;282	}283284	/// Get contract address.285	/// @dev EVM selector for this function is: 0xf6b4dfb4,286	///  or in textual repr: contractAddress()287	function contractAddress() public view returns (address) {288		require(false, stub_error);289		dummy;290		return 0x0000000000000000000000000000000000000000;291	}292293	/// Add collection admin.294	/// @param newAdmin Cross account administrator address.295	/// @dev EVM selector for this function is: 0x859aa7d6,296	///  or in textual 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((address,uint256))307	function removeCollectionAdminCross(EthCrossAccount memory admin) public {308		require(false, stub_error);309		admin;310		dummy = 0;311	}312313	// /// Add collection admin.314	// /// @param newAdmin Address of the added administrator.315	// /// @dev EVM selector for this function is: 0x92e462c7,316	// ///  or in textual repr: addCollectionAdmin(address)317	// function addCollectionAdmin(address newAdmin) public {318	// 	require(false, stub_error);319	// 	newAdmin;320	// 	dummy = 0;321	// }322323	// /// Remove collection admin.324	// ///325	// /// @param admin Address of the removed administrator.326	// /// @dev EVM selector for this function is: 0xfafd7b42,327	// ///  or in textual repr: removeCollectionAdmin(address)328	// function removeCollectionAdmin(address admin) public {329	// 	require(false, stub_error);330	// 	admin;331	// 	dummy = 0;332	// }333334	/// Toggle accessibility of collection nesting.335	///336	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'337	/// @dev EVM selector for this function is: 0x112d4586,338	///  or in textual repr: setCollectionNesting(bool)339	function setCollectionNesting(bool enable) public {340		require(false, stub_error);341		enable;342		dummy = 0;343	}344345	/// Toggle accessibility of collection nesting.346	///347	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'348	/// @param collections Addresses of collections that will be available for nesting.349	/// @dev EVM selector for this function is: 0x64872396,350	///  or in textual repr: setCollectionNesting(bool,address[])351	function setCollectionNesting(bool enable, address[] memory collections) public {352		require(false, stub_error);353		enable;354		collections;355		dummy = 0;356	}357358	/// Returns nesting for a collection359	/// @dev EVM selector for this function is: 0x22d25bfe,360	///  or in textual repr: collectionNestingRestrictedCollectionIds()361	function collectionNestingRestrictedCollectionIds() public view returns (Tuple33 memory) {362		require(false, stub_error);363		dummy;364		return Tuple33(false, new uint256[](0));365	}366367	/// Returns permissions for a collection368	/// @dev EVM selector for this function is: 0x5b2eaf4b,369	///  or in textual repr: collectionNestingPermissions()370	function collectionNestingPermissions() public view returns (Tuple36[] memory) {371		require(false, stub_error);372		dummy;373		return new Tuple36[](0);374	}375376	/// Set the collection access method.377	/// @param mode Access mode378	/// 	0 for Normal379	/// 	1 for AllowList380	/// @dev EVM selector for this function is: 0x41835d4c,381	///  or in textual repr: setCollectionAccess(uint8)382	function setCollectionAccess(uint8 mode) public {383		require(false, stub_error);384		mode;385		dummy = 0;386	}387388	/// Checks that user allowed to operate with collection.389	///390	/// @param user User address to check.391	/// @dev EVM selector for this function is: 0x91b6df49,392	///  or in textual repr: allowlistedCross((address,uint256))393	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {394		require(false, stub_error);395		user;396		dummy;397		return false;398	}399400	// /// Add the user to the allowed list.401	// ///402	// /// @param user Address of a trusted user.403	// /// @dev EVM selector for this function is: 0x67844fe6,404	// ///  or in textual repr: addToCollectionAllowList(address)405	// function addToCollectionAllowList(address user) public {406	// 	require(false, stub_error);407	// 	user;408	// 	dummy = 0;409	// }410411	/// Add user to allowed list.412	///413	/// @param user User cross account address.414	/// @dev EVM selector for this function is: 0xa0184a3a,415	///  or in textual repr: addToCollectionAllowListCross((address,uint256))416	function addToCollectionAllowListCross(EthCrossAccount memory user) public {417		require(false, stub_error);418		user;419		dummy = 0;420	}421422	// /// Remove the user from the allowed list.423	// ///424	// /// @param user Address of a removed user.425	// /// @dev EVM selector for this function is: 0x85c51acb,426	// ///  or in textual repr: removeFromCollectionAllowList(address)427	// function removeFromCollectionAllowList(address user) public {428	// 	require(false, stub_error);429	// 	user;430	// 	dummy = 0;431	// }432433	/// Remove user from allowed list.434	///435	/// @param user User cross account address.436	/// @dev EVM selector for this function is: 0x09ba452a,437	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))438	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {439		require(false, stub_error);440		user;441		dummy = 0;442	}443444	/// Switch permission for minting.445	///446	/// @param mode Enable if "true".447	/// @dev EVM selector for this function is: 0x00018e84,448	///  or in textual repr: setCollectionMintMode(bool)449	function setCollectionMintMode(bool mode) public {450		require(false, stub_error);451		mode;452		dummy = 0;453	}454455	// /// Check that account is the owner or admin of the collection456	// ///457	// /// @param user account to verify458	// /// @return "true" if account is the owner or admin459	// /// @dev EVM selector for this function is: 0x9811b0c7,460	// ///  or in textual repr: isOwnerOrAdmin(address)461	// function isOwnerOrAdmin(address user) public view returns (bool) {462	// 	require(false, stub_error);463	// 	user;464	// 	dummy;465	// 	return false;466	// }467468	/// Check that account is the owner or admin of the collection469	///470	/// @param user User cross account to verify471	/// @return "true" if account is the owner or admin472	/// @dev EVM selector for this function is: 0x3e75a905,473	///  or in textual repr: isOwnerOrAdminCross((address,uint256))474	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {475		require(false, stub_error);476		user;477		dummy;478		return false;479	}480481	/// Returns collection type482	///483	/// @return `Fungible` or `NFT` or `ReFungible`484	/// @dev EVM selector for this function is: 0xd34b55b8,485	///  or in textual repr: uniqueCollectionType()486	function uniqueCollectionType() public view returns (string memory) {487		require(false, stub_error);488		dummy;489		return "";490	}491492	/// Get collection owner.493	///494	/// @return Tuble with sponsor address and his substrate mirror.495	/// If address is canonical then substrate mirror is zero and vice versa.496	/// @dev EVM selector for this function is: 0xdf727d3b,497	///  or in textual repr: collectionOwner()498	function collectionOwner() public view returns (EthCrossAccount memory) {499		require(false, stub_error);500		dummy;501		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);502	}503504	// /// Changes collection owner to another account505	// ///506	// /// @dev Owner can be changed only by current owner507	// /// @param newOwner new owner account508	// /// @dev EVM selector for this function is: 0x4f53e226,509	// ///  or in textual repr: changeCollectionOwner(address)510	// function changeCollectionOwner(address newOwner) public {511	// 	require(false, stub_error);512	// 	newOwner;513	// 	dummy = 0;514	// }515516	/// Get collection administrators517	///518	/// @return Vector of tuples with admins address and his substrate mirror.519	/// If address is canonical then substrate mirror is zero and vice versa.520	/// @dev EVM selector for this function is: 0x5813216b,521	///  or in textual repr: collectionAdmins()522	function collectionAdmins() public view returns (EthCrossAccount[] memory) {523		require(false, stub_error);524		dummy;525		return new EthCrossAccount[](0);526	}527528	/// Changes collection owner to another account529	///530	/// @dev Owner can be changed only by current owner531	/// @param newOwner new owner cross account532	/// @dev EVM selector for this function is: 0x6496c497,533	///  or in textual repr: changeCollectionOwnerCross((address,uint256))534	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {535		require(false, stub_error);536		newOwner;537		dummy = 0;538	}539}540541/// @dev Cross account struct542struct EthCrossAccount {543	address eth;544	uint256 sub;545}546547enum CollectionPermissions {548	CollectionAdmin,549	TokenOwner550}551552/// @dev anonymous struct553struct Tuple36 {554	CollectionPermissions field_0;555	bool field_1;556}557558/// @dev anonymous struct559struct Tuple33 {560	bool field_0;561	uint256[] field_1;562}563564/// @dev anonymous struct565struct Tuple29 {566	address field_0;567	uint256 field_1;568}569570/// @dev the ERC-165 identifier for this interface is 0x5b5e139f571contract ERC721Metadata is Dummy, ERC165 {572	// /// @notice A descriptive name for a collection of NFTs in this contract573	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`574	// /// @dev EVM selector for this function is: 0x06fdde03,575	// ///  or in textual repr: name()576	// function name() public view returns (string memory) {577	// 	require(false, stub_error);578	// 	dummy;579	// 	return "";580	// }581582	// /// @notice An abbreviated name for NFTs in this contract583	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`584	// /// @dev EVM selector for this function is: 0x95d89b41,585	// ///  or in textual repr: symbol()586	// function symbol() public view returns (string memory) {587	// 	require(false, stub_error);588	// 	dummy;589	// 	return "";590	// }591592	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.593	///594	/// @dev If the token has a `url` property and it is not empty, it is returned.595	///  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`.596	///  If the collection property `baseURI` is empty or absent, return "" (empty string)597	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix598	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).599	///600	/// @return token's const_metadata601	/// @dev EVM selector for this function is: 0xc87b56dd,602	///  or in textual repr: tokenURI(uint256)603	function tokenURI(uint256 tokenId) public view returns (string memory) {604		require(false, stub_error);605		tokenId;606		dummy;607		return "";608	}609}610611/// @title ERC721 Token that can be irreversibly burned (destroyed).612/// @dev the ERC-165 identifier for this interface is 0x42966c68613contract ERC721Burnable is Dummy, ERC165 {614	/// @notice Burns a specific ERC721 token.615	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized616	///  operator of the current owner.617	/// @param tokenId The RFT to approve618	/// @dev EVM selector for this function is: 0x42966c68,619	///  or in textual repr: burn(uint256)620	function burn(uint256 tokenId) public {621		require(false, stub_error);622		tokenId;623		dummy = 0;624	}625}626627/// @dev inlined interface628contract ERC721UniqueMintableEvents {629	event MintingFinished();630}631632/// @title ERC721 minting logic.633/// @dev the ERC-165 identifier for this interface is 0x476ff149634contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {635	/// @dev EVM selector for this function is: 0x05d2035b,636	///  or in textual repr: mintingFinished()637	function mintingFinished() public view returns (bool) {638		require(false, stub_error);639		dummy;640		return false;641	}642643	/// @notice Function to mint token.644	/// @param to The new owner645	/// @return uint256 The id of the newly minted token646	/// @dev EVM selector for this function is: 0x6a627842,647	///  or in textual repr: mint(address)648	function mint(address to) public returns (uint256) {649		require(false, stub_error);650		to;651		dummy = 0;652		return 0;653	}654655	// /// @notice Function to mint token.656	// /// @dev `tokenId` should be obtained with `nextTokenId` method,657	// ///  unlike standard, you can't specify it manually658	// /// @param to The new owner659	// /// @param tokenId ID of the minted RFT660	// /// @dev EVM selector for this function is: 0x40c10f19,661	// ///  or in textual repr: mint(address,uint256)662	// function mint(address to, uint256 tokenId) public returns (bool) {663	// 	require(false, stub_error);664	// 	to;665	// 	tokenId;666	// 	dummy = 0;667	// 	return false;668	// }669670	/// @notice Function to mint token with the given tokenUri.671	/// @param to The new owner672	/// @param tokenUri Token URI that would be stored in the NFT properties673	/// @return uint256 The id of the newly minted token674	/// @dev EVM selector for this function is: 0x45c17782,675	///  or in textual repr: mintWithTokenURI(address,string)676	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {677		require(false, stub_error);678		to;679		tokenUri;680		dummy = 0;681		return 0;682	}683684	// /// @notice Function to mint token with the given tokenUri.685	// /// @dev `tokenId` should be obtained with `nextTokenId` method,686	// ///  unlike standard, you can't specify it manually687	// /// @param to The new owner688	// /// @param tokenId ID of the minted RFT689	// /// @param tokenUri Token URI that would be stored in the RFT properties690	// /// @dev EVM selector for this function is: 0x50bb4e7f,691	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)692	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {693	// 	require(false, stub_error);694	// 	to;695	// 	tokenId;696	// 	tokenUri;697	// 	dummy = 0;698	// 	return false;699	// }700701	/// @dev Not implemented702	/// @dev EVM selector for this function is: 0x7d64bcb4,703	///  or in textual repr: finishMinting()704	function finishMinting() public returns (bool) {705		require(false, stub_error);706		dummy = 0;707		return false;708	}709}710711/// @title Unique extensions for ERC721.712/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1713contract ERC721UniqueExtensions is Dummy, ERC165 {714	/// @notice A descriptive name for a collection of NFTs in this contract715	/// @dev EVM selector for this function is: 0x06fdde03,716	///  or in textual repr: name()717	function name() public view returns (string memory) {718		require(false, stub_error);719		dummy;720		return "";721	}722723	/// @notice An abbreviated name for NFTs in this contract724	/// @dev EVM selector for this function is: 0x95d89b41,725	///  or in textual repr: symbol()726	function symbol() public view returns (string memory) {727		require(false, stub_error);728		dummy;729		return "";730	}731732	/// @notice A description for the collection.733	/// @dev EVM selector for this function is: 0x7284e416,734	///  or in textual repr: description()735	function description() public view returns (string memory) {736		require(false, stub_error);737		dummy;738		return "";739	}740741	/// Returns the owner (in cross format) of the token.742	///743	/// @param tokenId Id for the token.744	/// @dev EVM selector for this function is: 0x2b29dace,745	///  or in textual repr: crossOwnerOf(uint256)746	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {747		require(false, stub_error);748		tokenId;749		dummy;750		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);751	}752753	/// Returns the token properties.754	///755	/// @param tokenId Id for the token.756	/// @param keys Properties keys. Empty keys for all propertyes.757	/// @return Vector of properties key/value pairs.758	/// @dev EVM selector for this function is: 0xe07ede7e,759	///  or in textual repr: properties(uint256,string[])760	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {761		require(false, stub_error);762		tokenId;763		keys;764		dummy;765		return new Property[](0);766	}767768	/// @notice Transfer ownership of an RFT769	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`770	///  is the zero address. Throws if `tokenId` is not a valid RFT.771	///  Throws if RFT pieces have multiple owners.772	/// @param to The new owner773	/// @param tokenId The RFT to transfer774	/// @dev EVM selector for this function is: 0xa9059cbb,775	///  or in textual repr: transfer(address,uint256)776	function transfer(address to, uint256 tokenId) public {777		require(false, stub_error);778		to;779		tokenId;780		dummy = 0;781	}782783	/// @notice Transfer ownership of an RFT784	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`785	///  is the zero address. Throws if `tokenId` is not a valid RFT.786	///  Throws if RFT pieces have multiple owners.787	/// @param to The new owner788	/// @param tokenId The RFT to transfer789	/// @dev EVM selector for this function is: 0x2ada85ff,790	///  or in textual repr: transferCross((address,uint256),uint256)791	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {792		require(false, stub_error);793		to;794		tokenId;795		dummy = 0;796	}797798	/// @notice Transfer ownership of an RFT799	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`800	///  is the zero address. Throws if `tokenId` is not a valid RFT.801	///  Throws if RFT pieces have multiple owners.802	/// @param to The new owner803	/// @param tokenId The RFT to transfer804	/// @dev EVM selector for this function is: 0xd5cf430b,805	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)806	function transferFromCross(807		EthCrossAccount memory from,808		EthCrossAccount memory to,809		uint256 tokenId810	) public {811		require(false, stub_error);812		from;813		to;814		tokenId;815		dummy = 0;816	}817818	// /// @notice Burns a specific ERC721 token.819	// /// @dev Throws unless `msg.sender` is the current owner or an authorized820	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws821	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.822	// ///  Throws if RFT pieces have multiple owners.823	// /// @param from The current owner of the RFT824	// /// @param tokenId The RFT to transfer825	// /// @dev EVM selector for this function is: 0x79cc6790,826	// ///  or in textual repr: burnFrom(address,uint256)827	// function burnFrom(address from, uint256 tokenId) public {828	// 	require(false, stub_error);829	// 	from;830	// 	tokenId;831	// 	dummy = 0;832	// }833834	/// @notice Burns a specific ERC721 token.835	/// @dev Throws unless `msg.sender` is the current owner or an authorized836	///  operator for this RFT. Throws if `from` is not the current owner. Throws837	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.838	///  Throws if RFT pieces have multiple owners.839	/// @param from The current owner of the RFT840	/// @param tokenId The RFT to transfer841	/// @dev EVM selector for this function is: 0xbb2f5a58,842	///  or in textual repr: burnFromCross((address,uint256),uint256)843	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {844		require(false, stub_error);845		from;846		tokenId;847		dummy = 0;848	}849850	/// @notice Returns next free RFT ID.851	/// @dev EVM selector for this function is: 0x75794a3c,852	///  or in textual repr: nextTokenId()853	function nextTokenId() public view returns (uint256) {854		require(false, stub_error);855		dummy;856		return 0;857	}858859	// /// @notice Function to mint multiple tokens.860	// /// @dev `tokenIds` should be an array of consecutive numbers and first number861	// ///  should be obtained with `nextTokenId` method862	// /// @param to The new owner863	// /// @param tokenIds IDs of the minted RFTs864	// /// @dev EVM selector for this function is: 0x44a9945e,865	// ///  or in textual repr: mintBulk(address,uint256[])866	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {867	// 	require(false, stub_error);868	// 	to;869	// 	tokenIds;870	// 	dummy = 0;871	// 	return false;872	// }873874	// /// @notice Function to mint multiple tokens with the given tokenUris.875	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive876	// ///  numbers and first number should be obtained with `nextTokenId` method877	// /// @param to The new owner878	// /// @param tokens array of pairs of token ID and token URI for minted tokens879	// /// @dev EVM selector for this function is: 0x36543006,880	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])881	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {882	// 	require(false, stub_error);883	// 	to;884	// 	tokens;885	// 	dummy = 0;886	// 	return false;887	// }888889	/// Returns EVM address for refungible token890	///891	/// @param token ID of the token892	/// @dev EVM selector for this function is: 0xab76fac6,893	///  or in textual repr: tokenContractAddress(uint256)894	function tokenContractAddress(uint256 token) public view returns (address) {895		require(false, stub_error);896		token;897		dummy;898		return 0x0000000000000000000000000000000000000000;899	}900}901902/// @dev anonymous struct903struct Tuple14 {904	uint256 field_0;905	string field_1;906}907908/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension909/// @dev See https://eips.ethereum.org/EIPS/eip-721910/// @dev the ERC-165 identifier for this interface is 0x780e9d63911contract ERC721Enumerable is Dummy, ERC165 {912	/// @notice Enumerate valid RFTs913	/// @param index A counter less than `totalSupply()`914	/// @return The token identifier for the `index`th NFT,915	///  (sort order not specified)916	/// @dev EVM selector for this function is: 0x4f6ccce7,917	///  or in textual repr: tokenByIndex(uint256)918	function tokenByIndex(uint256 index) public view returns (uint256) {919		require(false, stub_error);920		index;921		dummy;922		return 0;923	}924925	/// Not implemented926	/// @dev EVM selector for this function is: 0x2f745c59,927	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)928	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {929		require(false, stub_error);930		owner;931		index;932		dummy;933		return 0;934	}935936	/// @notice Count RFTs tracked by this contract937	/// @return A count of valid RFTs tracked by this contract, where each one of938	///  them has an assigned and queryable owner not equal to the zero address939	/// @dev EVM selector for this function is: 0x18160ddd,940	///  or in textual repr: totalSupply()941	function totalSupply() public view returns (uint256) {942		require(false, stub_error);943		dummy;944		return 0;945	}946}947948/// @dev inlined interface949contract ERC721Events {950	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);951	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);952	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);953}954955/// @title ERC-721 Non-Fungible Token Standard956/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md957/// @dev the ERC-165 identifier for this interface is 0x4016cd87958contract ERC721 is Dummy, ERC165, ERC721Events {959	/// @notice Count all RFTs assigned to an owner960	/// @dev RFTs assigned to the zero address are considered invalid, and this961	///  function throws for queries about the zero address.962	/// @param owner An address for whom to query the balance963	/// @return The number of RFTs owned by `owner`, possibly zero964	/// @dev EVM selector for this function is: 0x70a08231,965	///  or in textual repr: balanceOf(address)966	function balanceOf(address owner) public view returns (uint256) {967		require(false, stub_error);968		owner;969		dummy;970		return 0;971	}972973	/// @notice Find the owner of an RFT974	/// @dev RFTs assigned to zero address are considered invalid, and queries975	///  about them do throw.976	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for977	///  the tokens that are partially owned.978	/// @param tokenId The identifier for an RFT979	/// @return The address of the owner of the RFT980	/// @dev EVM selector for this function is: 0x6352211e,981	///  or in textual repr: ownerOf(uint256)982	function ownerOf(uint256 tokenId) public view returns (address) {983		require(false, stub_error);984		tokenId;985		dummy;986		return 0x0000000000000000000000000000000000000000;987	}988989	/// @dev Not implemented990	/// @dev EVM selector for this function is: 0x60a11672,991	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)992	function safeTransferFromWithData(993		address from,994		address to,995		uint256 tokenId,996		bytes memory data997	) public {998		require(false, stub_error);999		from;1000		to;1001		tokenId;1002		data;1003		dummy = 0;1004	}10051006	/// @dev Not implemented1007	/// @dev EVM selector for this function is: 0x42842e0e,1008	///  or in textual repr: safeTransferFrom(address,address,uint256)1009	function safeTransferFrom(1010		address from,1011		address to,1012		uint256 tokenId1013	) public {1014		require(false, stub_error);1015		from;1016		to;1017		tokenId;1018		dummy = 0;1019	}10201021	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1022	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1023	///  THEY MAY BE PERMANENTLY LOST1024	/// @dev Throws unless `msg.sender` is the current owner or an authorized1025	///  operator for this RFT. Throws if `from` is not the current owner. Throws1026	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1027	///  Throws if RFT pieces have multiple owners.1028	/// @param from The current owner of the NFT1029	/// @param to The new owner1030	/// @param tokenId The NFT to transfer1031	/// @dev EVM selector for this function is: 0x23b872dd,1032	///  or in textual repr: transferFrom(address,address,uint256)1033	function transferFrom(1034		address from,1035		address to,1036		uint256 tokenId1037	) public {1038		require(false, stub_error);1039		from;1040		to;1041		tokenId;1042		dummy = 0;1043	}10441045	/// @dev Not implemented1046	/// @dev EVM selector for this function is: 0x095ea7b3,1047	///  or in textual repr: approve(address,uint256)1048	function approve(address approved, uint256 tokenId) public {1049		require(false, stub_error);1050		approved;1051		tokenId;1052		dummy = 0;1053	}10541055	/// @notice Sets or unsets the approval of a given operator.1056	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1057	/// @param operator Operator1058	/// @param approved Should operator status be granted or revoked?1059	/// @dev EVM selector for this function is: 0xa22cb465,1060	///  or in textual repr: setApprovalForAll(address,bool)1061	function setApprovalForAll(address operator, bool approved) public {1062		require(false, stub_error);1063		operator;1064		approved;1065		dummy = 0;1066	}10671068	/// @dev Not implemented1069	/// @dev EVM selector for this function is: 0x081812fc,1070	///  or in textual repr: getApproved(uint256)1071	function getApproved(uint256 tokenId) public view returns (address) {1072		require(false, stub_error);1073		tokenId;1074		dummy;1075		return 0x0000000000000000000000000000000000000000;1076	}10771078	/// @notice Tells whether the given `owner` approves the `operator`.1079	/// @dev EVM selector for this function is: 0xe985e9c5,1080	///  or in textual repr: isApprovedForAll(address,address)1081	function isApprovedForAll(address owner, address operator) public view returns (bool) {1082		require(false, stub_error);1083		owner;1084		operator;1085		dummy;1086		return false;1087	}10881089	/// @notice Returns collection helper contract address1090	/// @dev EVM selector for this function is: 0x1896cce6,1091	///  or in textual repr: collectionHelperAddress()1092	function collectionHelperAddress() public view returns (address) {1093		require(false, stub_error);1094		dummy;1095		return 0x0000000000000000000000000000000000000000;1096	}1097}10981099contract UniqueRefungible is1100	Dummy,1101	ERC165,1102	ERC721,1103	ERC721Enumerable,1104	ERC721UniqueExtensions,1105	ERC721UniqueMintable,1106	ERC721Burnable,1107	ERC721Metadata,1108	Collection,1109	TokenProperties1110{}