git.delta.rocks / unique-network / refs/commits / 515ea8c66cf5

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((address,uint256))203	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {204		require(false, stub_error);205		sponsor;206		dummy = 0;207	}208209	/// Whether there is a pending sponsor.210	/// @dev EVM selector for this function is: 0x058ac185,211	///  or in textual repr: hasCollectionPendingSponsor()212	function hasCollectionPendingSponsor() public view returns (bool) {213		require(false, stub_error);214		dummy;215		return false;216	}217218	/// Collection sponsorship confirmation.219	///220	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.221	/// @dev EVM selector for this function is: 0x3c50e97a,222	///  or in textual repr: confirmCollectionSponsorship()223	function confirmCollectionSponsorship() public {224		require(false, stub_error);225		dummy = 0;226	}227228	/// Remove collection sponsor.229	/// @dev EVM selector for this function is: 0x6e0326a3,230	///  or in textual repr: removeCollectionSponsor()231	function removeCollectionSponsor() public {232		require(false, stub_error);233		dummy = 0;234	}235236	/// Get current sponsor.237	///238	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.239	/// @dev EVM selector for this function is: 0x6ec0a9f1,240	///  or in textual repr: collectionSponsor()241	function collectionSponsor() public view returns (Tuple23 memory) {242		require(false, stub_error);243		dummy;244		return Tuple23(0x0000000000000000000000000000000000000000, 0);245	}246247	/// Set limits for the collection.248	/// @dev Throws error if limit not found.249	/// @param limit Name of the limit. Valid names:250	/// 	"accountTokenOwnershipLimit",251	/// 	"sponsoredDataSize",252	/// 	"sponsoredDataRateLimit",253	/// 	"tokenLimit",254	/// 	"sponsorTransferTimeout",255	/// 	"sponsorApproveTimeout"256	/// @param value Value of the limit.257	/// @dev EVM selector for this function is: 0x6a3841db,258	///  or in textual repr: setCollectionLimit(string,uint32)259	function setCollectionLimit(string memory limit, uint32 value) public {260		require(false, stub_error);261		limit;262		value;263		dummy = 0;264	}265266	/// Set limits for the collection.267	/// @dev Throws error if limit not found.268	/// @param limit Name of the limit. Valid names:269	/// 	"ownerCanTransfer",270	/// 	"ownerCanDestroy",271	/// 	"transfersEnabled"272	/// @param value Value of the limit.273	/// @dev EVM selector for this function is: 0x993b7fba,274	///  or in textual repr: setCollectionLimit(string,bool)275	function setCollectionLimit(string memory limit, bool value) public {276		require(false, stub_error);277		limit;278		value;279		dummy = 0;280	}281282	/// Get contract address.283	/// @dev EVM selector for this function is: 0xf6b4dfb4,284	///  or in textual repr: contractAddress()285	function contractAddress() public view returns (address) {286		require(false, stub_error);287		dummy;288		return 0x0000000000000000000000000000000000000000;289	}290291	/// Add collection admin.292	/// @param newAdmin Cross account administrator address.293	/// @dev EVM selector for this function is: 0x859aa7d6,294	///  or in textual repr: addCollectionAdminCross((address,uint256))295	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {296		require(false, stub_error);297		newAdmin;298		dummy = 0;299	}300301	/// Remove collection admin.302	/// @param admin Cross account administrator address.303	/// @dev EVM selector for this function is: 0x6c0cd173,304	///  or in textual repr: removeCollectionAdminCross((address,uint256))305	function removeCollectionAdminCross(EthCrossAccount memory admin) public {306		require(false, stub_error);307		admin;308		dummy = 0;309	}310311	/// Add collection admin.312	/// @param newAdmin Address of the added administrator.313	/// @dev EVM selector for this function is: 0x92e462c7,314	///  or in textual repr: addCollectionAdmin(address)315	function addCollectionAdmin(address newAdmin) public {316		require(false, stub_error);317		newAdmin;318		dummy = 0;319	}320321	/// Remove collection admin.322	///323	/// @param admin Address of the removed administrator.324	/// @dev EVM selector for this function is: 0xfafd7b42,325	///  or in textual repr: removeCollectionAdmin(address)326	function removeCollectionAdmin(address admin) public {327		require(false, stub_error);328		admin;329		dummy = 0;330	}331332	/// Toggle accessibility of collection nesting.333	///334	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'335	/// @dev EVM selector for this function is: 0x112d4586,336	///  or in textual repr: setCollectionNesting(bool)337	function setCollectionNesting(bool enable) public {338		require(false, stub_error);339		enable;340		dummy = 0;341	}342343	/// Toggle accessibility of collection nesting.344	///345	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'346	/// @param collections Addresses of collections that will be available for nesting.347	/// @dev EVM selector for this function is: 0x64872396,348	///  or in textual repr: setCollectionNesting(bool,address[])349	function setCollectionNesting(bool enable, address[] memory collections) public {350		require(false, stub_error);351		enable;352		collections;353		dummy = 0;354	}355356	/// Set the collection access method.357	/// @param mode Access mode358	/// 	0 for Normal359	/// 	1 for AllowList360	/// @dev EVM selector for this function is: 0x41835d4c,361	///  or in textual repr: setCollectionAccess(uint8)362	function setCollectionAccess(uint8 mode) public {363		require(false, stub_error);364		mode;365		dummy = 0;366	}367368	/// Checks that user allowed to operate with collection.369	///370	/// @param user User address to check.371	/// @dev EVM selector for this function is: 0xd63a8e11,372	///  or in textual repr: allowed(address)373	function allowed(address user) public view returns (bool) {374		require(false, stub_error);375		user;376		dummy;377		return false;378	}379380	/// Add the user to the allowed list.381	///382	/// @param user Address of a trusted user.383	/// @dev EVM selector for this function is: 0x67844fe6,384	///  or in textual repr: addToCollectionAllowList(address)385	function addToCollectionAllowList(address user) public {386		require(false, stub_error);387		user;388		dummy = 0;389	}390391	/// Add user to allowed list.392	///393	/// @param user User cross account address.394	/// @dev EVM selector for this function is: 0xa0184a3a,395	///  or in textual repr: addToCollectionAllowListCross((address,uint256))396	function addToCollectionAllowListCross(EthCrossAccount memory user) public {397		require(false, stub_error);398		user;399		dummy = 0;400	}401402	/// Remove the user from the allowed list.403	///404	/// @param user Address of a removed user.405	/// @dev EVM selector for this function is: 0x85c51acb,406	///  or in textual repr: removeFromCollectionAllowList(address)407	function removeFromCollectionAllowList(address user) public {408		require(false, stub_error);409		user;410		dummy = 0;411	}412413	/// Remove user from allowed list.414	///415	/// @param user User cross account address.416	/// @dev EVM selector for this function is: 0x09ba452a,417	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))418	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {419		require(false, stub_error);420		user;421		dummy = 0;422	}423424	/// Switch permission for minting.425	///426	/// @param mode Enable if "true".427	/// @dev EVM selector for this function is: 0x00018e84,428	///  or in textual repr: setCollectionMintMode(bool)429	function setCollectionMintMode(bool mode) public {430		require(false, stub_error);431		mode;432		dummy = 0;433	}434435	/// Check that account is the owner or admin of the collection436	///437	/// @param user account to verify438	/// @return "true" if account is the owner or admin439	/// @dev EVM selector for this function is: 0x9811b0c7,440	///  or in textual repr: isOwnerOrAdmin(address)441	function isOwnerOrAdmin(address user) public view returns (bool) {442		require(false, stub_error);443		user;444		dummy;445		return false;446	}447448	/// Check that account is the owner or admin of the collection449	///450	/// @param user User cross account to verify451	/// @return "true" if account is the owner or admin452	/// @dev EVM selector for this function is: 0x3e75a905,453	///  or in textual repr: isOwnerOrAdminCross((address,uint256))454	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {455		require(false, stub_error);456		user;457		dummy;458		return false;459	}460461	/// Returns collection type462	///463	/// @return `Fungible` or `NFT` or `ReFungible`464	/// @dev EVM selector for this function is: 0xd34b55b8,465	///  or in textual repr: uniqueCollectionType()466	function uniqueCollectionType() public view returns (string memory) {467		require(false, stub_error);468		dummy;469		return "";470	}471472	/// Get collection owner.473	///474	/// @return Tuble with sponsor address and his substrate mirror.475	/// If address is canonical then substrate mirror is zero and vice versa.476	/// @dev EVM selector for this function is: 0xdf727d3b,477	///  or in textual repr: collectionOwner()478	function collectionOwner() public view returns (EthCrossAccount memory) {479		require(false, stub_error);480		dummy;481		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);482	}483484	/// Changes collection owner to another account485	///486	/// @dev Owner can be changed only by current owner487	/// @param newOwner new owner account488	/// @dev EVM selector for this function is: 0x4f53e226,489	///  or in textual repr: changeCollectionOwner(address)490	function changeCollectionOwner(address newOwner) public {491		require(false, stub_error);492		newOwner;493		dummy = 0;494	}495496	/// Get collection administrators497	///498	/// @return Vector of tuples with admins address and his substrate mirror.499	/// If address is canonical then substrate mirror is zero and vice versa.500	/// @dev EVM selector for this function is: 0x5813216b,501	///  or in textual repr: collectionAdmins()502	function collectionAdmins() public view returns (EthCrossAccount[] memory) {503		require(false, stub_error);504		dummy;505		return new EthCrossAccount[](0);506	}507508	/// Changes collection owner to another account509	///510	/// @dev Owner can be changed only by current owner511	/// @param newOwner new owner cross account512	/// @dev EVM selector for this function is: 0xe5c9913f,513	///  or in textual repr: setOwnerCross((address,uint256))514	function setOwnerCross(EthCrossAccount memory newOwner) public {515		require(false, stub_error);516		newOwner;517		dummy = 0;518	}519}520521/// @dev Cross account struct522struct EthCrossAccount {523	address eth;524	uint256 sub;525}526527/// @dev anonymous struct528struct Tuple23 {529	address field_0;530	uint256 field_1;531}532533/// @dev anonymous struct534struct Tuple20 {535	string field_0;536	bytes field_1;537}538539/// @dev the ERC-165 identifier for this interface is 0x5b5e139f540contract ERC721Metadata is Dummy, ERC165 {541	// /// @notice A descriptive name for a collection of NFTs in this contract542	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`543	// /// @dev EVM selector for this function is: 0x06fdde03,544	// ///  or in textual repr: name()545	// function name() public view returns (string memory) {546	// 	require(false, stub_error);547	// 	dummy;548	// 	return "";549	// }550551	// /// @notice An abbreviated name for NFTs in this contract552	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`553	// /// @dev EVM selector for this function is: 0x95d89b41,554	// ///  or in textual repr: symbol()555	// function symbol() public view returns (string memory) {556	// 	require(false, stub_error);557	// 	dummy;558	// 	return "";559	// }560561	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.562	///563	/// @dev If the token has a `url` property and it is not empty, it is returned.564	///  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`.565	///  If the collection property `baseURI` is empty or absent, return "" (empty string)566	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix567	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).568	///569	/// @return token's const_metadata570	/// @dev EVM selector for this function is: 0xc87b56dd,571	///  or in textual repr: tokenURI(uint256)572	function tokenURI(uint256 tokenId) public view returns (string memory) {573		require(false, stub_error);574		tokenId;575		dummy;576		return "";577	}578}579580/// @title ERC721 Token that can be irreversibly burned (destroyed).581/// @dev the ERC-165 identifier for this interface is 0x42966c68582contract ERC721Burnable is Dummy, ERC165 {583	/// @notice Burns a specific ERC721 token.584	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized585	///  operator of the current owner.586	/// @param tokenId The RFT to approve587	/// @dev EVM selector for this function is: 0x42966c68,588	///  or in textual repr: burn(uint256)589	function burn(uint256 tokenId) public {590		require(false, stub_error);591		tokenId;592		dummy = 0;593	}594}595596/// @dev inlined interface597contract ERC721UniqueMintableEvents {598	event MintingFinished();599}600601/// @title ERC721 minting logic.602/// @dev the ERC-165 identifier for this interface is 0x476ff149603contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {604	/// @dev EVM selector for this function is: 0x05d2035b,605	///  or in textual repr: mintingFinished()606	function mintingFinished() public view returns (bool) {607		require(false, stub_error);608		dummy;609		return false;610	}611612	/// @notice Function to mint token.613	/// @param to The new owner614	/// @return uint256 The id of the newly minted token615	/// @dev EVM selector for this function is: 0x6a627842,616	///  or in textual repr: mint(address)617	function mint(address to) public returns (uint256) {618		require(false, stub_error);619		to;620		dummy = 0;621		return 0;622	}623624	// /// @notice Function to mint token.625	// /// @dev `tokenId` should be obtained with `nextTokenId` method,626	// ///  unlike standard, you can't specify it manually627	// /// @param to The new owner628	// /// @param tokenId ID of the minted RFT629	// /// @dev EVM selector for this function is: 0x40c10f19,630	// ///  or in textual repr: mint(address,uint256)631	// function mint(address to, uint256 tokenId) public returns (bool) {632	// 	require(false, stub_error);633	// 	to;634	// 	tokenId;635	// 	dummy = 0;636	// 	return false;637	// }638639	/// @notice Function to mint token with the given tokenUri.640	/// @param to The new owner641	/// @param tokenUri Token URI that would be stored in the NFT properties642	/// @return uint256 The id of the newly minted token643	/// @dev EVM selector for this function is: 0x45c17782,644	///  or in textual repr: mintWithTokenURI(address,string)645	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {646		require(false, stub_error);647		to;648		tokenUri;649		dummy = 0;650		return 0;651	}652653	// /// @notice Function to mint token with the given tokenUri.654	// /// @dev `tokenId` should be obtained with `nextTokenId` method,655	// ///  unlike standard, you can't specify it manually656	// /// @param to The new owner657	// /// @param tokenId ID of the minted RFT658	// /// @param tokenUri Token URI that would be stored in the RFT properties659	// /// @dev EVM selector for this function is: 0x50bb4e7f,660	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)661	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {662	// 	require(false, stub_error);663	// 	to;664	// 	tokenId;665	// 	tokenUri;666	// 	dummy = 0;667	// 	return false;668	// }669670	/// @dev Not implemented671	/// @dev EVM selector for this function is: 0x7d64bcb4,672	///  or in textual repr: finishMinting()673	function finishMinting() public returns (bool) {674		require(false, stub_error);675		dummy = 0;676		return false;677	}678}679680/// @title Unique extensions for ERC721.681/// @dev the ERC-165 identifier for this interface is 0x81feb398682contract ERC721UniqueExtensions is Dummy, ERC165 {683	/// @notice A descriptive name for a collection of NFTs in this contract684	/// @dev EVM selector for this function is: 0x06fdde03,685	///  or in textual repr: name()686	function name() public view returns (string memory) {687		require(false, stub_error);688		dummy;689		return "";690	}691692	/// @notice An abbreviated name for NFTs in this contract693	/// @dev EVM selector for this function is: 0x95d89b41,694	///  or in textual repr: symbol()695	function symbol() public view returns (string memory) {696		require(false, stub_error);697		dummy;698		return "";699	}700701	/// @notice Transfer ownership of an RFT702	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`703	///  is the zero address. Throws if `tokenId` is not a valid RFT.704	///  Throws if RFT pieces have multiple owners.705	/// @param to The new owner706	/// @param tokenId The RFT to transfer707	/// @dev EVM selector for this function is: 0xa9059cbb,708	///  or in textual repr: transfer(address,uint256)709	function transfer(address to, uint256 tokenId) public {710		require(false, stub_error);711		to;712		tokenId;713		dummy = 0;714	}715716	/// @notice Transfer ownership of an RFT717	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`718	///  is the zero address. Throws if `tokenId` is not a valid RFT.719	///  Throws if RFT pieces have multiple owners.720	/// @param to The new owner721	/// @param tokenId The RFT to transfer722	/// @dev EVM selector for this function is: 0xd5cf430b,723	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)724	function transferFromCross(725		EthCrossAccount memory from,726		EthCrossAccount memory to,727		uint256 tokenId728	) public {729		require(false, stub_error);730		from;731		to;732		tokenId;733		dummy = 0;734	}735736	/// @notice Burns a specific ERC721 token.737	/// @dev Throws unless `msg.sender` is the current owner or an authorized738	///  operator for this RFT. Throws if `from` is not the current owner. Throws739	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.740	///  Throws if RFT pieces have multiple owners.741	/// @param from The current owner of the RFT742	/// @param tokenId The RFT to transfer743	/// @dev EVM selector for this function is: 0x79cc6790,744	///  or in textual repr: burnFrom(address,uint256)745	function burnFrom(address from, uint256 tokenId) public {746		require(false, stub_error);747		from;748		tokenId;749		dummy = 0;750	}751752	/// @notice Burns a specific ERC721 token.753	/// @dev Throws unless `msg.sender` is the current owner or an authorized754	///  operator for this RFT. Throws if `from` is not the current owner. Throws755	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.756	///  Throws if RFT pieces have multiple owners.757	/// @param from The current owner of the RFT758	/// @param tokenId The RFT to transfer759	/// @dev EVM selector for this function is: 0xbb2f5a58,760	///  or in textual repr: burnFromCross((address,uint256),uint256)761	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {762		require(false, stub_error);763		from;764		tokenId;765		dummy = 0;766	}767768	/// @notice Returns next free RFT ID.769	/// @dev EVM selector for this function is: 0x75794a3c,770	///  or in textual repr: nextTokenId()771	function nextTokenId() public view returns (uint256) {772		require(false, stub_error);773		dummy;774		return 0;775	}776777	// /// @notice Function to mint multiple tokens.778	// /// @dev `tokenIds` should be an array of consecutive numbers and first number779	// ///  should be obtained with `nextTokenId` method780	// /// @param to The new owner781	// /// @param tokenIds IDs of the minted RFTs782	// /// @dev EVM selector for this function is: 0x44a9945e,783	// ///  or in textual repr: mintBulk(address,uint256[])784	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {785	// 	require(false, stub_error);786	// 	to;787	// 	tokenIds;788	// 	dummy = 0;789	// 	return false;790	// }791792	// /// @notice Function to mint multiple tokens with the given tokenUris.793	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive794	// ///  numbers and first number should be obtained with `nextTokenId` method795	// /// @param to The new owner796	// /// @param tokens array of pairs of token ID and token URI for minted tokens797	// /// @dev EVM selector for this function is: 0x36543006,798	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])799	// function mintBulkWithTokenURI(address to, Tuple9[] memory tokens) public returns (bool) {800	// 	require(false, stub_error);801	// 	to;802	// 	tokens;803	// 	dummy = 0;804	// 	return false;805	// }806807	/// Returns EVM address for refungible token808	///809	/// @param token ID of the token810	/// @dev EVM selector for this function is: 0xab76fac6,811	///  or in textual repr: tokenContractAddress(uint256)812	function tokenContractAddress(uint256 token) public view returns (address) {813		require(false, stub_error);814		token;815		dummy;816		return 0x0000000000000000000000000000000000000000;817	}818}819820/// @dev anonymous struct821struct Tuple9 {822	uint256 field_0;823	string field_1;824}825826/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension827/// @dev See https://eips.ethereum.org/EIPS/eip-721828/// @dev the ERC-165 identifier for this interface is 0x780e9d63829contract ERC721Enumerable is Dummy, ERC165 {830	/// @notice Enumerate valid RFTs831	/// @param index A counter less than `totalSupply()`832	/// @return The token identifier for the `index`th NFT,833	///  (sort order not specified)834	/// @dev EVM selector for this function is: 0x4f6ccce7,835	///  or in textual repr: tokenByIndex(uint256)836	function tokenByIndex(uint256 index) public view returns (uint256) {837		require(false, stub_error);838		index;839		dummy;840		return 0;841	}842843	/// Not implemented844	/// @dev EVM selector for this function is: 0x2f745c59,845	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)846	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {847		require(false, stub_error);848		owner;849		index;850		dummy;851		return 0;852	}853854	/// @notice Count RFTs tracked by this contract855	/// @return A count of valid RFTs tracked by this contract, where each one of856	///  them has an assigned and queryable owner not equal to the zero address857	/// @dev EVM selector for this function is: 0x18160ddd,858	///  or in textual repr: totalSupply()859	function totalSupply() public view returns (uint256) {860		require(false, stub_error);861		dummy;862		return 0;863	}864}865866/// @dev inlined interface867contract ERC721Events {868	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);869	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);870	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);871}872873/// @title ERC-721 Non-Fungible Token Standard874/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md875/// @dev the ERC-165 identifier for this interface is 0x58800161876contract ERC721 is Dummy, ERC165, ERC721Events {877	/// @notice Count all RFTs assigned to an owner878	/// @dev RFTs assigned to the zero address are considered invalid, and this879	///  function throws for queries about the zero address.880	/// @param owner An address for whom to query the balance881	/// @return The number of RFTs owned by `owner`, possibly zero882	/// @dev EVM selector for this function is: 0x70a08231,883	///  or in textual repr: balanceOf(address)884	function balanceOf(address owner) public view returns (uint256) {885		require(false, stub_error);886		owner;887		dummy;888		return 0;889	}890891	/// @notice Find the owner of an RFT892	/// @dev RFTs assigned to zero address are considered invalid, and queries893	///  about them do throw.894	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for895	///  the tokens that are partially owned.896	/// @param tokenId The identifier for an RFT897	/// @return The address of the owner of the RFT898	/// @dev EVM selector for this function is: 0x6352211e,899	///  or in textual repr: ownerOf(uint256)900	function ownerOf(uint256 tokenId) public view returns (address) {901		require(false, stub_error);902		tokenId;903		dummy;904		return 0x0000000000000000000000000000000000000000;905	}906907	/// @dev Not implemented908	/// @dev EVM selector for this function is: 0x60a11672,909	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)910	function safeTransferFromWithData(911		address from,912		address to,913		uint256 tokenId,914		bytes memory data915	) public {916		require(false, stub_error);917		from;918		to;919		tokenId;920		data;921		dummy = 0;922	}923924	/// @dev Not implemented925	/// @dev EVM selector for this function is: 0x42842e0e,926	///  or in textual repr: safeTransferFrom(address,address,uint256)927	function safeTransferFrom(928		address from,929		address to,930		uint256 tokenId931	) public {932		require(false, stub_error);933		from;934		to;935		tokenId;936		dummy = 0;937	}938939	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE940	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE941	///  THEY MAY BE PERMANENTLY LOST942	/// @dev Throws unless `msg.sender` is the current owner or an authorized943	///  operator for this RFT. Throws if `from` is not the current owner. Throws944	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.945	///  Throws if RFT pieces have multiple owners.946	/// @param from The current owner of the NFT947	/// @param to The new owner948	/// @param tokenId The NFT to transfer949	/// @dev EVM selector for this function is: 0x23b872dd,950	///  or in textual repr: transferFrom(address,address,uint256)951	function transferFrom(952		address from,953		address to,954		uint256 tokenId955	) public {956		require(false, stub_error);957		from;958		to;959		tokenId;960		dummy = 0;961	}962963	/// @dev Not implemented964	/// @dev EVM selector for this function is: 0x095ea7b3,965	///  or in textual repr: approve(address,uint256)966	function approve(address approved, uint256 tokenId) public {967		require(false, stub_error);968		approved;969		tokenId;970		dummy = 0;971	}972973	/// @dev Not implemented974	/// @dev EVM selector for this function is: 0xa22cb465,975	///  or in textual repr: setApprovalForAll(address,bool)976	function setApprovalForAll(address operator, bool approved) public {977		require(false, stub_error);978		operator;979		approved;980		dummy = 0;981	}982983	/// @dev Not implemented984	/// @dev EVM selector for this function is: 0x081812fc,985	///  or in textual repr: getApproved(uint256)986	function getApproved(uint256 tokenId) public view returns (address) {987		require(false, stub_error);988		tokenId;989		dummy;990		return 0x0000000000000000000000000000000000000000;991	}992993	/// @dev Not implemented994	/// @dev EVM selector for this function is: 0xe985e9c5,995	///  or in textual repr: isApprovedForAll(address,address)996	function isApprovedForAll(address owner, address operator) public view returns (address) {997		require(false, stub_error);998		owner;999		operator;1000		dummy;1001		return 0x0000000000000000000000000000000000000000;1002	}1003}10041005contract UniqueRefungible is1006	Dummy,1007	ERC165,1008	ERC721,1009	ERC721Enumerable,1010	ERC721UniqueExtensions,1011	ERC721UniqueMintable,1012	ERC721Burnable,1013	ERC721Metadata,1014	Collection,1015	TokenProperties1016{}