git.delta.rocks / unique-network / refs/commits / 93efc9e5e22c

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 0x8b91d192123contract 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 (Tuple22[] memory) {192		require(false, stub_error);193		keys;194		dummy;195		return new Tuple22[](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 (Tuple25 memory) {257		require(false, stub_error);258		dummy;259		return Tuple25(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	/// Set the collection access method.359	/// @param mode Access mode360	/// 	0 for Normal361	/// 	1 for AllowList362	/// @dev EVM selector for this function is: 0x41835d4c,363	///  or in textual repr: setCollectionAccess(uint8)364	function setCollectionAccess(uint8 mode) public {365		require(false, stub_error);366		mode;367		dummy = 0;368	}369370	/// Checks that user allowed to operate with collection.371	///372	/// @param user User address to check.373	/// @dev EVM selector for this function is: 0xd63a8e11,374	///  or in textual repr: allowed(address)375	function allowed(address user) public view returns (bool) {376		require(false, stub_error);377		user;378		dummy;379		return false;380	}381382	// /// Add the user to the allowed list.383	// ///384	// /// @param user Address of a trusted user.385	// /// @dev EVM selector for this function is: 0x67844fe6,386	// ///  or in textual repr: addToCollectionAllowList(address)387	// function addToCollectionAllowList(address user) public {388	// 	require(false, stub_error);389	// 	user;390	// 	dummy = 0;391	// }392393	/// Add user to allowed list.394	///395	/// @param user User cross account address.396	/// @dev EVM selector for this function is: 0xa0184a3a,397	///  or in textual repr: addToCollectionAllowListCross((address,uint256))398	function addToCollectionAllowListCross(EthCrossAccount memory user) public {399		require(false, stub_error);400		user;401		dummy = 0;402	}403404	// /// Remove the user from the allowed list.405	// ///406	// /// @param user Address of a removed user.407	// /// @dev EVM selector for this function is: 0x85c51acb,408	// ///  or in textual repr: removeFromCollectionAllowList(address)409	// function removeFromCollectionAllowList(address user) public {410	// 	require(false, stub_error);411	// 	user;412	// 	dummy = 0;413	// }414415	/// Remove user from allowed list.416	///417	/// @param user User cross account address.418	/// @dev EVM selector for this function is: 0x09ba452a,419	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))420	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {421		require(false, stub_error);422		user;423		dummy = 0;424	}425426	/// Switch permission for minting.427	///428	/// @param mode Enable if "true".429	/// @dev EVM selector for this function is: 0x00018e84,430	///  or in textual repr: setCollectionMintMode(bool)431	function setCollectionMintMode(bool mode) public {432		require(false, stub_error);433		mode;434		dummy = 0;435	}436437	// /// Check that account is the owner or admin of the collection438	// ///439	// /// @param user account to verify440	// /// @return "true" if account is the owner or admin441	// /// @dev EVM selector for this function is: 0x9811b0c7,442	// ///  or in textual repr: isOwnerOrAdmin(address)443	// function isOwnerOrAdmin(address user) public view returns (bool) {444	// 	require(false, stub_error);445	// 	user;446	// 	dummy;447	// 	return false;448	// }449450	/// Check that account is the owner or admin of the collection451	///452	/// @param user User cross account to verify453	/// @return "true" if account is the owner or admin454	/// @dev EVM selector for this function is: 0x3e75a905,455	///  or in textual repr: isOwnerOrAdminCross((address,uint256))456	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {457		require(false, stub_error);458		user;459		dummy;460		return false;461	}462463	/// Returns collection type464	///465	/// @return `Fungible` or `NFT` or `ReFungible`466	/// @dev EVM selector for this function is: 0xd34b55b8,467	///  or in textual repr: uniqueCollectionType()468	function uniqueCollectionType() public view returns (string memory) {469		require(false, stub_error);470		dummy;471		return "";472	}473474	/// Get collection owner.475	///476	/// @return Tuble with sponsor address and his substrate mirror.477	/// If address is canonical then substrate mirror is zero and vice versa.478	/// @dev EVM selector for this function is: 0xdf727d3b,479	///  or in textual repr: collectionOwner()480	function collectionOwner() public view returns (EthCrossAccount memory) {481		require(false, stub_error);482		dummy;483		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);484	}485486	// /// Changes collection owner to another account487	// ///488	// /// @dev Owner can be changed only by current owner489	// /// @param newOwner new owner account490	// /// @dev EVM selector for this function is: 0x4f53e226,491	// ///  or in textual repr: changeCollectionOwner(address)492	// function changeCollectionOwner(address newOwner) public {493	// 	require(false, stub_error);494	// 	newOwner;495	// 	dummy = 0;496	// }497498	/// Get collection administrators499	///500	/// @return Vector of tuples with admins address and his substrate mirror.501	/// If address is canonical then substrate mirror is zero and vice versa.502	/// @dev EVM selector for this function is: 0x5813216b,503	///  or in textual repr: collectionAdmins()504	function collectionAdmins() public view returns (EthCrossAccount[] memory) {505		require(false, stub_error);506		dummy;507		return new EthCrossAccount[](0);508	}509510	/// Changes collection owner to another account511	///512	/// @dev Owner can be changed only by current owner513	/// @param newOwner new owner cross account514	/// @dev EVM selector for this function is: 0x6496c497,515	///  or in textual repr: changeCollectionOwnerCross((address,uint256))516	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {517		require(false, stub_error);518		newOwner;519		dummy = 0;520	}521}522523/// @dev Cross account struct524struct EthCrossAccount {525	address eth;526	uint256 sub;527}528529/// @dev anonymous struct530struct Tuple25 {531	address field_0;532	uint256 field_1;533}534535/// @dev anonymous struct536struct Tuple22 {537	string field_0;538	bytes field_1;539}540541/// @dev the ERC-165 identifier for this interface is 0x5b5e139f542contract ERC721Metadata is Dummy, ERC165 {543	// /// @notice A descriptive name for a collection of NFTs in this contract544	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`545	// /// @dev EVM selector for this function is: 0x06fdde03,546	// ///  or in textual repr: name()547	// function name() public view returns (string memory) {548	// 	require(false, stub_error);549	// 	dummy;550	// 	return "";551	// }552553	// /// @notice An abbreviated name for NFTs in this contract554	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`555	// /// @dev EVM selector for this function is: 0x95d89b41,556	// ///  or in textual repr: symbol()557	// function symbol() public view returns (string memory) {558	// 	require(false, stub_error);559	// 	dummy;560	// 	return "";561	// }562563	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.564	///565	/// @dev If the token has a `url` property and it is not empty, it is returned.566	///  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`.567	///  If the collection property `baseURI` is empty or absent, return "" (empty string)568	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix569	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).570	///571	/// @return token's const_metadata572	/// @dev EVM selector for this function is: 0xc87b56dd,573	///  or in textual repr: tokenURI(uint256)574	function tokenURI(uint256 tokenId) public view returns (string memory) {575		require(false, stub_error);576		tokenId;577		dummy;578		return "";579	}580}581582/// @title ERC721 Token that can be irreversibly burned (destroyed).583/// @dev the ERC-165 identifier for this interface is 0x42966c68584contract ERC721Burnable is Dummy, ERC165 {585	/// @notice Burns a specific ERC721 token.586	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized587	///  operator of the current owner.588	/// @param tokenId The RFT to approve589	/// @dev EVM selector for this function is: 0x42966c68,590	///  or in textual repr: burn(uint256)591	function burn(uint256 tokenId) public {592		require(false, stub_error);593		tokenId;594		dummy = 0;595	}596}597598/// @dev inlined interface599contract ERC721UniqueMintableEvents {600	event MintingFinished();601}602603/// @title ERC721 minting logic.604/// @dev the ERC-165 identifier for this interface is 0x476ff149605contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {606	/// @dev EVM selector for this function is: 0x05d2035b,607	///  or in textual repr: mintingFinished()608	function mintingFinished() public view returns (bool) {609		require(false, stub_error);610		dummy;611		return false;612	}613614	/// @notice Function to mint token.615	/// @param to The new owner616	/// @return uint256 The id of the newly minted token617	/// @dev EVM selector for this function is: 0x6a627842,618	///  or in textual repr: mint(address)619	function mint(address to) public returns (uint256) {620		require(false, stub_error);621		to;622		dummy = 0;623		return 0;624	}625626	// /// @notice Function to mint token.627	// /// @dev `tokenId` should be obtained with `nextTokenId` method,628	// ///  unlike standard, you can't specify it manually629	// /// @param to The new owner630	// /// @param tokenId ID of the minted RFT631	// /// @dev EVM selector for this function is: 0x40c10f19,632	// ///  or in textual repr: mint(address,uint256)633	// function mint(address to, uint256 tokenId) public returns (bool) {634	// 	require(false, stub_error);635	// 	to;636	// 	tokenId;637	// 	dummy = 0;638	// 	return false;639	// }640641	/// @notice Function to mint token with the given tokenUri.642	/// @param to The new owner643	/// @param tokenUri Token URI that would be stored in the NFT properties644	/// @return uint256 The id of the newly minted token645	/// @dev EVM selector for this function is: 0x45c17782,646	///  or in textual repr: mintWithTokenURI(address,string)647	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {648		require(false, stub_error);649		to;650		tokenUri;651		dummy = 0;652		return 0;653	}654655	// /// @notice Function to mint token with the given tokenUri.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	// /// @param tokenUri Token URI that would be stored in the RFT properties661	// /// @dev EVM selector for this function is: 0x50bb4e7f,662	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)663	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {664	// 	require(false, stub_error);665	// 	to;666	// 	tokenId;667	// 	tokenUri;668	// 	dummy = 0;669	// 	return false;670	// }671672	/// @dev Not implemented673	/// @dev EVM selector for this function is: 0x7d64bcb4,674	///  or in textual repr: finishMinting()675	function finishMinting() public returns (bool) {676		require(false, stub_error);677		dummy = 0;678		return false;679	}680}681682/// @title Unique extensions for ERC721.683/// @dev the ERC-165 identifier for this interface is 0xab243667684contract ERC721UniqueExtensions is Dummy, ERC165 {685	/// @notice A descriptive name for a collection of NFTs in this contract686	/// @dev EVM selector for this function is: 0x06fdde03,687	///  or in textual repr: name()688	function name() public view returns (string memory) {689		require(false, stub_error);690		dummy;691		return "";692	}693694	/// @notice An abbreviated name for NFTs in this contract695	/// @dev EVM selector for this function is: 0x95d89b41,696	///  or in textual repr: symbol()697	function symbol() public view returns (string memory) {698		require(false, stub_error);699		dummy;700		return "";701	}702703	/// @notice A description for the collection.704	/// @dev EVM selector for this function is: 0x7284e416,705	///  or in textual repr: description()706	function description() public view returns (string memory) {707		require(false, stub_error);708		dummy;709		return "";710	}711712	/// Returns the owner (in cross format) of the token.713	///714	/// @param tokenId Id for the token.715	/// @dev EVM selector for this function is: 0x2b29dace,716	///  or in textual repr: crossOwnerOf(uint256)717	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {718		require(false, stub_error);719		tokenId;720		dummy;721		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);722	}723724	/// Returns the token properties.725	///726	/// @param tokenId Id for the token.727	/// @param keys Properties keys. Empty keys for all propertyes.728	/// @return Vector of properties key/value pairs.729	/// @dev EVM selector for this function is: 0xefc26c69,730	///  or in textual repr: tokenProperties(uint256,string[])731	function tokenProperties(uint256 tokenId, string[] memory keys) public view returns (Tuple8[] memory) {732		require(false, stub_error);733		tokenId;734		keys;735		dummy;736		return new Tuple8[](0);737	}738739	/// @notice Transfer ownership of an RFT740	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`741	///  is the zero address. Throws if `tokenId` is not a valid RFT.742	///  Throws if RFT pieces have multiple owners.743	/// @param to The new owner744	/// @param tokenId The RFT to transfer745	/// @dev EVM selector for this function is: 0xa9059cbb,746	///  or in textual repr: transfer(address,uint256)747	function transfer(address to, uint256 tokenId) public {748		require(false, stub_error);749		to;750		tokenId;751		dummy = 0;752	}753754	/// @notice Transfer ownership of an RFT755	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`756	///  is the zero address. Throws if `tokenId` is not a valid RFT.757	///  Throws if RFT pieces have multiple owners.758	/// @param to The new owner759	/// @param tokenId The RFT to transfer760	/// @dev EVM selector for this function is: 0x2ada85ff,761	///  or in textual repr: transferCross((address,uint256),uint256)762	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {763		require(false, stub_error);764		to;765		tokenId;766		dummy = 0;767	}768769	/// @notice Transfer ownership of an RFT770	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`771	///  is the zero address. Throws if `tokenId` is not a valid RFT.772	///  Throws if RFT pieces have multiple owners.773	/// @param to The new owner774	/// @param tokenId The RFT to transfer775	/// @dev EVM selector for this function is: 0xd5cf430b,776	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)777	function transferFromCross(778		EthCrossAccount memory from,779		EthCrossAccount memory to,780		uint256 tokenId781	) public {782		require(false, stub_error);783		from;784		to;785		tokenId;786		dummy = 0;787	}788789	// /// @notice Burns a specific ERC721 token.790	// /// @dev Throws unless `msg.sender` is the current owner or an authorized791	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws792	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.793	// ///  Throws if RFT pieces have multiple owners.794	// /// @param from The current owner of the RFT795	// /// @param tokenId The RFT to transfer796	// /// @dev EVM selector for this function is: 0x79cc6790,797	// ///  or in textual repr: burnFrom(address,uint256)798	// function burnFrom(address from, uint256 tokenId) public {799	// 	require(false, stub_error);800	// 	from;801	// 	tokenId;802	// 	dummy = 0;803	// }804805	/// @notice Burns a specific ERC721 token.806	/// @dev Throws unless `msg.sender` is the current owner or an authorized807	///  operator for this RFT. Throws if `from` is not the current owner. Throws808	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.809	///  Throws if RFT pieces have multiple owners.810	/// @param from The current owner of the RFT811	/// @param tokenId The RFT to transfer812	/// @dev EVM selector for this function is: 0xbb2f5a58,813	///  or in textual repr: burnFromCross((address,uint256),uint256)814	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {815		require(false, stub_error);816		from;817		tokenId;818		dummy = 0;819	}820821	/// @notice Returns next free RFT ID.822	/// @dev EVM selector for this function is: 0x75794a3c,823	///  or in textual repr: nextTokenId()824	function nextTokenId() public view returns (uint256) {825		require(false, stub_error);826		dummy;827		return 0;828	}829830	// /// @notice Function to mint multiple tokens.831	// /// @dev `tokenIds` should be an array of consecutive numbers and first number832	// ///  should be obtained with `nextTokenId` method833	// /// @param to The new owner834	// /// @param tokenIds IDs of the minted RFTs835	// /// @dev EVM selector for this function is: 0x44a9945e,836	// ///  or in textual repr: mintBulk(address,uint256[])837	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {838	// 	require(false, stub_error);839	// 	to;840	// 	tokenIds;841	// 	dummy = 0;842	// 	return false;843	// }844845	// /// @notice Function to mint multiple tokens with the given tokenUris.846	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive847	// ///  numbers and first number should be obtained with `nextTokenId` method848	// /// @param to The new owner849	// /// @param tokens array of pairs of token ID and token URI for minted tokens850	// /// @dev EVM selector for this function is: 0x36543006,851	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])852	// function mintBulkWithTokenURI(address to, Tuple10[] memory tokens) public returns (bool) {853	// 	require(false, stub_error);854	// 	to;855	// 	tokens;856	// 	dummy = 0;857	// 	return false;858	// }859860	/// Returns EVM address for refungible token861	///862	/// @param token ID of the token863	/// @dev EVM selector for this function is: 0xab76fac6,864	///  or in textual repr: tokenContractAddress(uint256)865	function tokenContractAddress(uint256 token) public view returns (address) {866		require(false, stub_error);867		token;868		dummy;869		return 0x0000000000000000000000000000000000000000;870	}871}872873/// @dev anonymous struct874struct Tuple10 {875	uint256 field_0;876	string field_1;877}878879/// @dev anonymous struct880struct Tuple8 {881	string field_0;882	bytes field_1;883}884885/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension886/// @dev See https://eips.ethereum.org/EIPS/eip-721887/// @dev the ERC-165 identifier for this interface is 0x780e9d63888contract ERC721Enumerable is Dummy, ERC165 {889	/// @notice Enumerate valid RFTs890	/// @param index A counter less than `totalSupply()`891	/// @return The token identifier for the `index`th NFT,892	///  (sort order not specified)893	/// @dev EVM selector for this function is: 0x4f6ccce7,894	///  or in textual repr: tokenByIndex(uint256)895	function tokenByIndex(uint256 index) public view returns (uint256) {896		require(false, stub_error);897		index;898		dummy;899		return 0;900	}901902	/// Not implemented903	/// @dev EVM selector for this function is: 0x2f745c59,904	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)905	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {906		require(false, stub_error);907		owner;908		index;909		dummy;910		return 0;911	}912913	/// @notice Count RFTs tracked by this contract914	/// @return A count of valid RFTs tracked by this contract, where each one of915	///  them has an assigned and queryable owner not equal to the zero address916	/// @dev EVM selector for this function is: 0x18160ddd,917	///  or in textual repr: totalSupply()918	function totalSupply() public view returns (uint256) {919		require(false, stub_error);920		dummy;921		return 0;922	}923}924925/// @dev inlined interface926contract ERC721Events {927	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);928	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);929	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);930}931932/// @title ERC-721 Non-Fungible Token Standard933/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md934/// @dev the ERC-165 identifier for this interface is 0x58800161935contract ERC721 is Dummy, ERC165, ERC721Events {936	/// @notice Count all RFTs assigned to an owner937	/// @dev RFTs assigned to the zero address are considered invalid, and this938	///  function throws for queries about the zero address.939	/// @param owner An address for whom to query the balance940	/// @return The number of RFTs owned by `owner`, possibly zero941	/// @dev EVM selector for this function is: 0x70a08231,942	///  or in textual repr: balanceOf(address)943	function balanceOf(address owner) public view returns (uint256) {944		require(false, stub_error);945		owner;946		dummy;947		return 0;948	}949950	/// @notice Find the owner of an RFT951	/// @dev RFTs assigned to zero address are considered invalid, and queries952	///  about them do throw.953	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for954	///  the tokens that are partially owned.955	/// @param tokenId The identifier for an RFT956	/// @return The address of the owner of the RFT957	/// @dev EVM selector for this function is: 0x6352211e,958	///  or in textual repr: ownerOf(uint256)959	function ownerOf(uint256 tokenId) public view returns (address) {960		require(false, stub_error);961		tokenId;962		dummy;963		return 0x0000000000000000000000000000000000000000;964	}965966	/// @dev Not implemented967	/// @dev EVM selector for this function is: 0x60a11672,968	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)969	function safeTransferFromWithData(970		address from,971		address to,972		uint256 tokenId,973		bytes memory data974	) public {975		require(false, stub_error);976		from;977		to;978		tokenId;979		data;980		dummy = 0;981	}982983	/// @dev Not implemented984	/// @dev EVM selector for this function is: 0x42842e0e,985	///  or in textual repr: safeTransferFrom(address,address,uint256)986	function safeTransferFrom(987		address from,988		address to,989		uint256 tokenId990	) public {991		require(false, stub_error);992		from;993		to;994		tokenId;995		dummy = 0;996	}997998	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE999	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1000	///  THEY MAY BE PERMANENTLY LOST1001	/// @dev Throws unless `msg.sender` is the current owner or an authorized1002	///  operator for this RFT. Throws if `from` is not the current owner. Throws1003	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1004	///  Throws if RFT pieces have multiple owners.1005	/// @param from The current owner of the NFT1006	/// @param to The new owner1007	/// @param tokenId The NFT to transfer1008	/// @dev EVM selector for this function is: 0x23b872dd,1009	///  or in textual repr: transferFrom(address,address,uint256)1010	function transferFrom(1011		address from,1012		address to,1013		uint256 tokenId1014	) public {1015		require(false, stub_error);1016		from;1017		to;1018		tokenId;1019		dummy = 0;1020	}10211022	/// @dev Not implemented1023	/// @dev EVM selector for this function is: 0x095ea7b3,1024	///  or in textual repr: approve(address,uint256)1025	function approve(address approved, uint256 tokenId) public {1026		require(false, stub_error);1027		approved;1028		tokenId;1029		dummy = 0;1030	}10311032	/// @dev Not implemented1033	/// @dev EVM selector for this function is: 0xa22cb465,1034	///  or in textual repr: setApprovalForAll(address,bool)1035	function setApprovalForAll(address operator, bool approved) public {1036		require(false, stub_error);1037		operator;1038		approved;1039		dummy = 0;1040	}10411042	/// @dev Not implemented1043	/// @dev EVM selector for this function is: 0x081812fc,1044	///  or in textual repr: getApproved(uint256)1045	function getApproved(uint256 tokenId) public view returns (address) {1046		require(false, stub_error);1047		tokenId;1048		dummy;1049		return 0x0000000000000000000000000000000000000000;1050	}10511052	/// @dev Not implemented1053	/// @dev EVM selector for this function is: 0xe985e9c5,1054	///  or in textual repr: isApprovedForAll(address,address)1055	function isApprovedForAll(address owner, address operator) public view returns (address) {1056		require(false, stub_error);1057		owner;1058		operator;1059		dummy;1060		return 0x0000000000000000000000000000000000000000;1061	}1062}10631064contract UniqueRefungible is1065	Dummy,1066	ERC165,1067	ERC721,1068	ERC721Enumerable,1069	ERC721UniqueExtensions,1070	ERC721UniqueMintable,1071	ERC721Burnable,1072	ERC721Metadata,1073	Collection,1074	TokenProperties1075{}