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

1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8	uint8 dummy;9	string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13	function supportsInterface(bytes4 interfaceID) external view returns (bool) {14		require(false, stub_error);15		interfaceID;16		return true;17	}18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0xde0695c222contract TokenProperties is Dummy, ERC165 {23	// /// @notice Set permissions for token property.24	// /// @dev Throws error if `msg.sender` is not admin or owner of the collection.25	// /// @param key Property key.26	// /// @param isMutable Permission to mutate property.27	// /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28	// /// @param tokenOwner Permission to mutate property by token owner if property is mutable.29	// /// @dev EVM selector for this function is: 0x222d97fa,30	// ///  or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31	// function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {32	// 	require(false, stub_error);33	// 	key;34	// 	isMutable;35	// 	collectionAdmin;36	// 	tokenOwner;37	// 	dummy = 0;38	// }3940	/// @notice Set permissions for token property.41	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.42	/// @param permissions Permissions for keys.43	/// @dev EVM selector for this function is: 0xbd92983a,44	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])45	function setTokenPropertyPermissions(Tuple48[] memory permissions) public {46		require(false, stub_error);47		permissions;48		dummy = 0;49	}5051	/// @dev EVM selector for this function is: 0xf23d7790,52	///  or in textual repr: tokenPropertyPermissions()53	function tokenPropertyPermissions() public view returns (Tuple48[] memory) {54		require(false, stub_error);55		dummy;56		return new Tuple48[](0);57	}5859	// /// @notice Set token property value.60	// /// @dev Throws error if `msg.sender` has no permission to edit the property.61	// /// @param tokenId ID of the token.62	// /// @param key Property key.63	// /// @param value Property value.64	// /// @dev EVM selector for this function is: 0x1752d67b,65	// ///  or in textual repr: setProperty(uint256,string,bytes)66	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {67	// 	require(false, stub_error);68	// 	tokenId;69	// 	key;70	// 	value;71	// 	dummy = 0;72	// }7374	/// @notice Set token properties value.75	/// @dev Throws error if `msg.sender` has no permission to edit the property.76	/// @param tokenId ID of the token.77	/// @param properties settable properties78	/// @dev EVM selector for this function is: 0x14ed3a6e,79	///  or in textual repr: setProperties(uint256,(string,bytes)[])80	function setProperties(uint256 tokenId, Property[] memory properties) public {81		require(false, stub_error);82		tokenId;83		properties;84		dummy = 0;85	}8687	// /// @notice Delete token property value.88	// /// @dev Throws error if `msg.sender` has no permission to edit the property.89	// /// @param tokenId ID of the token.90	// /// @param key Property key.91	// /// @dev EVM selector for this function is: 0x066111d1,92	// ///  or in textual repr: deleteProperty(uint256,string)93	// function deleteProperty(uint256 tokenId, string memory key) public {94	// 	require(false, stub_error);95	// 	tokenId;96	// 	key;97	// 	dummy = 0;98	// }99100	/// @notice Delete token properties value.101	/// @dev Throws error if `msg.sender` has no permission to edit the property.102	/// @param tokenId ID of the token.103	/// @param keys Properties key.104	/// @dev EVM selector for this function is: 0xc472d371,105	///  or in textual repr: deleteProperties(uint256,string[])106	function deleteProperties(uint256 tokenId, string[] memory keys) public {107		require(false, stub_error);108		tokenId;109		keys;110		dummy = 0;111	}112113	/// @notice Get token property value.114	/// @dev Throws error if key not found115	/// @param tokenId ID of the token.116	/// @param key Property key.117	/// @return Property value bytes118	/// @dev EVM selector for this function is: 0x7228c327,119	///  or in textual repr: property(uint256,string)120	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {121		require(false, stub_error);122		tokenId;123		key;124		dummy;125		return hex"";126	}127}128129/// @dev Property struct130struct Property {131	string key;132	bytes value;133}134135enum EthTokenPermissions {136	Mutable,137	TokenOwner,138	CollectionAdmin139}140141/// @dev anonymous struct142struct Tuple48 {143	string field_0;144	Tuple46[] field_1;145}146147/// @dev anonymous struct148struct Tuple46 {149	EthTokenPermissions field_0;150	bool field_1;151}152153/// @title A contract that allows you to work with collections.154/// @dev the ERC-165 identifier for this interface is 0x81172a75155contract Collection is Dummy, ERC165 {156	// /// Set collection property.157	// ///158	// /// @param key Property key.159	// /// @param value Propery value.160	// /// @dev EVM selector for this function is: 0x2f073f66,161	// ///  or in textual repr: setCollectionProperty(string,bytes)162	// function setCollectionProperty(string memory key, bytes memory value) public {163	// 	require(false, stub_error);164	// 	key;165	// 	value;166	// 	dummy = 0;167	// }168169	/// Set collection properties.170	///171	/// @param properties Vector of properties key/value pair.172	/// @dev EVM selector for this function is: 0x50b26b2a,173	///  or in textual repr: setCollectionProperties((string,bytes)[])174	function setCollectionProperties(Property[] memory properties) public {175		require(false, stub_error);176		properties;177		dummy = 0;178	}179180	// /// Delete collection property.181	// ///182	// /// @param key Property key.183	// /// @dev EVM selector for this function is: 0x7b7debce,184	// ///  or in textual repr: deleteCollectionProperty(string)185	// function deleteCollectionProperty(string memory key) public {186	// 	require(false, stub_error);187	// 	key;188	// 	dummy = 0;189	// }190191	/// Delete collection properties.192	///193	/// @param keys Properties keys.194	/// @dev EVM selector for this function is: 0xee206ee3,195	///  or in textual repr: deleteCollectionProperties(string[])196	function deleteCollectionProperties(string[] memory keys) public {197		require(false, stub_error);198		keys;199		dummy = 0;200	}201202	/// Get collection property.203	///204	/// @dev Throws error if key not found.205	///206	/// @param key Property key.207	/// @return bytes The property corresponding to the key.208	/// @dev EVM selector for this function is: 0xcf24fd6d,209	///  or in textual repr: collectionProperty(string)210	function collectionProperty(string memory key) public view returns (bytes memory) {211		require(false, stub_error);212		key;213		dummy;214		return hex"";215	}216217	/// Get collection properties.218	///219	/// @param keys Properties keys. Empty keys for all propertyes.220	/// @return Vector of properties key/value pairs.221	/// @dev EVM selector for this function is: 0x285fb8e6,222	///  or in textual repr: collectionProperties(string[])223	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {224		require(false, stub_error);225		keys;226		dummy;227		return new Property[](0);228	}229230	// /// Set the sponsor of the collection.231	// ///232	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.233	// ///234	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.235	// /// @dev EVM selector for this function is: 0x7623402e,236	// ///  or in textual repr: setCollectionSponsor(address)237	// function setCollectionSponsor(address sponsor) public {238	// 	require(false, stub_error);239	// 	sponsor;240	// 	dummy = 0;241	// }242243	/// Set the sponsor of the collection.244	///245	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.246	///247	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.248	/// @dev EVM selector for this function is: 0x84a1d5a8,249	///  or in textual repr: setCollectionSponsorCross((address,uint256))250	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {251		require(false, stub_error);252		sponsor;253		dummy = 0;254	}255256	/// Whether there is a pending sponsor.257	/// @dev EVM selector for this function is: 0x058ac185,258	///  or in textual repr: hasCollectionPendingSponsor()259	function hasCollectionPendingSponsor() public view returns (bool) {260		require(false, stub_error);261		dummy;262		return false;263	}264265	/// Collection sponsorship confirmation.266	///267	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.268	/// @dev EVM selector for this function is: 0x3c50e97a,269	///  or in textual repr: confirmCollectionSponsorship()270	function confirmCollectionSponsorship() public {271		require(false, stub_error);272		dummy = 0;273	}274275	/// Remove collection sponsor.276	/// @dev EVM selector for this function is: 0x6e0326a3,277	///  or in textual repr: removeCollectionSponsor()278	function removeCollectionSponsor() public {279		require(false, stub_error);280		dummy = 0;281	}282283	/// Get current sponsor.284	///285	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.286	/// @dev EVM selector for this function is: 0x6ec0a9f1,287	///  or in textual repr: collectionSponsor()288	function collectionSponsor() public view returns (Tuple30 memory) {289		require(false, stub_error);290		dummy;291		return Tuple30(0x0000000000000000000000000000000000000000, 0);292	}293294	/// Get current collection limits.295	///296	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:297	/// 	"accountTokenOwnershipLimit",298	/// 	"sponsoredDataSize",299	/// 	"sponsoredDataRateLimit",300	/// 	"tokenLimit",301	/// 	"sponsorTransferTimeout",302	/// 	"sponsorApproveTimeout"303	///  	"ownerCanTransfer",304	/// 	"ownerCanDestroy",305	/// 	"transfersEnabled"306	/// Return `false` if a limit not set.307	/// @dev EVM selector for this function is: 0xf63bc572,308	///  or in textual repr: collectionLimits()309	function collectionLimits() public view returns (Tuple33[] memory) {310		require(false, stub_error);311		dummy;312		return new Tuple33[](0);313	}314315	/// Set limits for the collection.316	/// @dev Throws error if limit not found.317	/// @param limit Name of the limit. Valid names:318	/// 	"accountTokenOwnershipLimit",319	/// 	"sponsoredDataSize",320	/// 	"sponsoredDataRateLimit",321	/// 	"tokenLimit",322	/// 	"sponsorTransferTimeout",323	/// 	"sponsorApproveTimeout"324	///  	"ownerCanTransfer",325	/// 	"ownerCanDestroy",326	/// 	"transfersEnabled"327	/// @param status enable\disable limit. Works only with `true`.328	/// @param value Value of the limit.329	/// @dev EVM selector for this function is: 0x88150bd0,330	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)331	function setCollectionLimit(332		CollectionLimits limit,333		bool status,334		uint256 value335	) public {336		require(false, stub_error);337		limit;338		status;339		value;340		dummy = 0;341	}342343	/// Get contract address.344	/// @dev EVM selector for this function is: 0xf6b4dfb4,345	///  or in textual repr: contractAddress()346	function contractAddress() public view returns (address) {347		require(false, stub_error);348		dummy;349		return 0x0000000000000000000000000000000000000000;350	}351352	/// Add collection admin.353	/// @param newAdmin Cross account administrator address.354	/// @dev EVM selector for this function is: 0x859aa7d6,355	///  or in textual repr: addCollectionAdminCross((address,uint256))356	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {357		require(false, stub_error);358		newAdmin;359		dummy = 0;360	}361362	/// Remove collection admin.363	/// @param admin Cross account administrator address.364	/// @dev EVM selector for this function is: 0x6c0cd173,365	///  or in textual repr: removeCollectionAdminCross((address,uint256))366	function removeCollectionAdminCross(EthCrossAccount memory admin) public {367		require(false, stub_error);368		admin;369		dummy = 0;370	}371372	// /// Add collection admin.373	// /// @param newAdmin Address of the added administrator.374	// /// @dev EVM selector for this function is: 0x92e462c7,375	// ///  or in textual repr: addCollectionAdmin(address)376	// function addCollectionAdmin(address newAdmin) public {377	// 	require(false, stub_error);378	// 	newAdmin;379	// 	dummy = 0;380	// }381382	// /// Remove collection admin.383	// ///384	// /// @param admin Address of the removed administrator.385	// /// @dev EVM selector for this function is: 0xfafd7b42,386	// ///  or in textual repr: removeCollectionAdmin(address)387	// function removeCollectionAdmin(address admin) public {388	// 	require(false, stub_error);389	// 	admin;390	// 	dummy = 0;391	// }392393	/// Toggle accessibility of collection nesting.394	///395	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'396	/// @dev EVM selector for this function is: 0x112d4586,397	///  or in textual repr: setCollectionNesting(bool)398	function setCollectionNesting(bool enable) public {399		require(false, stub_error);400		enable;401		dummy = 0;402	}403404	/// Toggle accessibility of collection nesting.405	///406	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'407	/// @param collections Addresses of collections that will be available for nesting.408	/// @dev EVM selector for this function is: 0x64872396,409	///  or in textual repr: setCollectionNesting(bool,address[])410	function setCollectionNesting(bool enable, address[] memory collections) public {411		require(false, stub_error);412		enable;413		collections;414		dummy = 0;415	}416417	/// Returns nesting for a collection418	/// @dev EVM selector for this function is: 0x22d25bfe,419	///  or in textual repr: collectionNestingRestrictedCollectionIds()420	function collectionNestingRestrictedCollectionIds() public view returns (Tuple39 memory) {421		require(false, stub_error);422		dummy;423		return Tuple39(false, new uint256[](0));424	}425426	/// Returns permissions for a collection427	/// @dev EVM selector for this function is: 0x5b2eaf4b,428	///  or in textual repr: collectionNestingPermissions()429	function collectionNestingPermissions() public view returns (Tuple42[] memory) {430		require(false, stub_error);431		dummy;432		return new Tuple42[](0);433	}434435	/// Set the collection access method.436	/// @param mode Access mode437	/// 	0 for Normal438	/// 	1 for AllowList439	/// @dev EVM selector for this function is: 0x41835d4c,440	///  or in textual repr: setCollectionAccess(uint8)441	function setCollectionAccess(uint8 mode) public {442		require(false, stub_error);443		mode;444		dummy = 0;445	}446447	/// Checks that user allowed to operate with collection.448	///449	/// @param user User address to check.450	/// @dev EVM selector for this function is: 0x91b6df49,451	///  or in textual repr: allowlistedCross((address,uint256))452	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {453		require(false, stub_error);454		user;455		dummy;456		return false;457	}458459	// /// Add the user to the allowed list.460	// ///461	// /// @param user Address of a trusted user.462	// /// @dev EVM selector for this function is: 0x67844fe6,463	// ///  or in textual repr: addToCollectionAllowList(address)464	// function addToCollectionAllowList(address user) public {465	// 	require(false, stub_error);466	// 	user;467	// 	dummy = 0;468	// }469470	/// Add user to allowed list.471	///472	/// @param user User cross account address.473	/// @dev EVM selector for this function is: 0xa0184a3a,474	///  or in textual repr: addToCollectionAllowListCross((address,uint256))475	function addToCollectionAllowListCross(EthCrossAccount memory user) public {476		require(false, stub_error);477		user;478		dummy = 0;479	}480481	// /// Remove the user from the allowed list.482	// ///483	// /// @param user Address of a removed user.484	// /// @dev EVM selector for this function is: 0x85c51acb,485	// ///  or in textual repr: removeFromCollectionAllowList(address)486	// function removeFromCollectionAllowList(address user) public {487	// 	require(false, stub_error);488	// 	user;489	// 	dummy = 0;490	// }491492	/// Remove user from allowed list.493	///494	/// @param user User cross account address.495	/// @dev EVM selector for this function is: 0x09ba452a,496	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))497	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {498		require(false, stub_error);499		user;500		dummy = 0;501	}502503	/// Switch permission for minting.504	///505	/// @param mode Enable if "true".506	/// @dev EVM selector for this function is: 0x00018e84,507	///  or in textual repr: setCollectionMintMode(bool)508	function setCollectionMintMode(bool mode) public {509		require(false, stub_error);510		mode;511		dummy = 0;512	}513514	// /// Check that account is the owner or admin of the collection515	// ///516	// /// @param user account to verify517	// /// @return "true" if account is the owner or admin518	// /// @dev EVM selector for this function is: 0x9811b0c7,519	// ///  or in textual repr: isOwnerOrAdmin(address)520	// function isOwnerOrAdmin(address user) public view returns (bool) {521	// 	require(false, stub_error);522	// 	user;523	// 	dummy;524	// 	return false;525	// }526527	/// Check that account is the owner or admin of the collection528	///529	/// @param user User cross account to verify530	/// @return "true" if account is the owner or admin531	/// @dev EVM selector for this function is: 0x3e75a905,532	///  or in textual repr: isOwnerOrAdminCross((address,uint256))533	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {534		require(false, stub_error);535		user;536		dummy;537		return false;538	}539540	/// Returns collection type541	///542	/// @return `Fungible` or `NFT` or `ReFungible`543	/// @dev EVM selector for this function is: 0xd34b55b8,544	///  or in textual repr: uniqueCollectionType()545	function uniqueCollectionType() public view returns (string memory) {546		require(false, stub_error);547		dummy;548		return "";549	}550551	/// Get collection owner.552	///553	/// @return Tuble with sponsor address and his substrate mirror.554	/// If address is canonical then substrate mirror is zero and vice versa.555	/// @dev EVM selector for this function is: 0xdf727d3b,556	///  or in textual repr: collectionOwner()557	function collectionOwner() public view returns (EthCrossAccount memory) {558		require(false, stub_error);559		dummy;560		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);561	}562563	// /// Changes collection owner to another account564	// ///565	// /// @dev Owner can be changed only by current owner566	// /// @param newOwner new owner account567	// /// @dev EVM selector for this function is: 0x4f53e226,568	// ///  or in textual repr: changeCollectionOwner(address)569	// function changeCollectionOwner(address newOwner) public {570	// 	require(false, stub_error);571	// 	newOwner;572	// 	dummy = 0;573	// }574575	/// Get collection administrators576	///577	/// @return Vector of tuples with admins address and his substrate mirror.578	/// If address is canonical then substrate mirror is zero and vice versa.579	/// @dev EVM selector for this function is: 0x5813216b,580	///  or in textual repr: collectionAdmins()581	function collectionAdmins() public view returns (EthCrossAccount[] memory) {582		require(false, stub_error);583		dummy;584		return new EthCrossAccount[](0);585	}586587	/// Changes collection owner to another account588	///589	/// @dev Owner can be changed only by current owner590	/// @param newOwner new owner cross account591	/// @dev EVM selector for this function is: 0x6496c497,592	///  or in textual repr: changeCollectionOwnerCross((address,uint256))593	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {594		require(false, stub_error);595		newOwner;596		dummy = 0;597	}598}599600/// @dev Cross account struct601struct EthCrossAccount {602	address eth;603	uint256 sub;604}605606enum CollectionPermissions {607	CollectionAdmin,608	TokenOwner609}610611/// @dev anonymous struct612struct Tuple42 {613	CollectionPermissions field_0;614	bool field_1;615}616617/// @dev anonymous struct618struct Tuple39 {619	bool field_0;620	uint256[] field_1;621}622623enum CollectionLimits {624	AccountTokenOwnership,625	SponsoredDataSize,626	SponsoredDataRateLimit,627	TokenLimit,628	SponsorTransferTimeout,629	SponsorApproveTimeout,630	OwnerCanTransfer,631	OwnerCanDestroy,632	TransferEnabled633}634635/// @dev anonymous struct636struct Tuple33 {637	CollectionLimits field_0;638	bool field_1;639	uint256 field_2;640}641642/// @dev anonymous struct643struct Tuple30 {644	address field_0;645	uint256 field_1;646}647648/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension649/// @dev See https://eips.ethereum.org/EIPS/eip-721650/// @dev the ERC-165 identifier for this interface is 0x5b5e139f651contract ERC721Metadata is Dummy, ERC165 {652	// /// @notice A descriptive name for a collection of NFTs in this contract653	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`654	// /// @dev EVM selector for this function is: 0x06fdde03,655	// ///  or in textual repr: name()656	// function name() public view returns (string memory) {657	// 	require(false, stub_error);658	// 	dummy;659	// 	return "";660	// }661662	// /// @notice An abbreviated name for NFTs in this contract663	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`664	// /// @dev EVM selector for this function is: 0x95d89b41,665	// ///  or in textual repr: symbol()666	// function symbol() public view returns (string memory) {667	// 	require(false, stub_error);668	// 	dummy;669	// 	return "";670	// }671672	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.673	///674	/// @dev If the token has a `url` property and it is not empty, it is returned.675	///  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`.676	///  If the collection property `baseURI` is empty or absent, return "" (empty string)677	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix678	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).679	///680	/// @return token's const_metadata681	/// @dev EVM selector for this function is: 0xc87b56dd,682	///  or in textual repr: tokenURI(uint256)683	function tokenURI(uint256 tokenId) public view returns (string memory) {684		require(false, stub_error);685		tokenId;686		dummy;687		return "";688	}689}690691/// @title ERC721 Token that can be irreversibly burned (destroyed).692/// @dev the ERC-165 identifier for this interface is 0x42966c68693contract ERC721Burnable is Dummy, ERC165 {694	/// @notice Burns a specific ERC721 token.695	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized696	///  operator of the current owner.697	/// @param tokenId The NFT to approve698	/// @dev EVM selector for this function is: 0x42966c68,699	///  or in textual repr: burn(uint256)700	function burn(uint256 tokenId) public {701		require(false, stub_error);702		tokenId;703		dummy = 0;704	}705}706707/// @dev inlined interface708contract ERC721UniqueMintableEvents {709	event MintingFinished();710}711712/// @title ERC721 minting logic.713/// @dev the ERC-165 identifier for this interface is 0x476ff149714contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {715	/// @dev EVM selector for this function is: 0x05d2035b,716	///  or in textual repr: mintingFinished()717	function mintingFinished() public view returns (bool) {718		require(false, stub_error);719		dummy;720		return false;721	}722723	/// @notice Function to mint token.724	/// @param to The new owner725	/// @return uint256 The id of the newly minted token726	/// @dev EVM selector for this function is: 0x6a627842,727	///  or in textual repr: mint(address)728	function mint(address to) public returns (uint256) {729		require(false, stub_error);730		to;731		dummy = 0;732		return 0;733	}734735	// /// @notice Function to mint token.736	// /// @dev `tokenId` should be obtained with `nextTokenId` method,737	// ///  unlike standard, you can't specify it manually738	// /// @param to The new owner739	// /// @param tokenId ID of the minted NFT740	// /// @dev EVM selector for this function is: 0x40c10f19,741	// ///  or in textual repr: mint(address,uint256)742	// function mint(address to, uint256 tokenId) public returns (bool) {743	// 	require(false, stub_error);744	// 	to;745	// 	tokenId;746	// 	dummy = 0;747	// 	return false;748	// }749750	/// @notice Function to mint token with the given tokenUri.751	/// @param to The new owner752	/// @param tokenUri Token URI that would be stored in the NFT properties753	/// @return uint256 The id of the newly minted token754	/// @dev EVM selector for this function is: 0x45c17782,755	///  or in textual repr: mintWithTokenURI(address,string)756	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {757		require(false, stub_error);758		to;759		tokenUri;760		dummy = 0;761		return 0;762	}763764	// /// @notice Function to mint token with the given tokenUri.765	// /// @dev `tokenId` should be obtained with `nextTokenId` method,766	// ///  unlike standard, you can't specify it manually767	// /// @param to The new owner768	// /// @param tokenId ID of the minted NFT769	// /// @param tokenUri Token URI that would be stored in the NFT properties770	// /// @dev EVM selector for this function is: 0x50bb4e7f,771	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)772	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {773	// 	require(false, stub_error);774	// 	to;775	// 	tokenId;776	// 	tokenUri;777	// 	dummy = 0;778	// 	return false;779	// }780781	/// @dev Not implemented782	/// @dev EVM selector for this function is: 0x7d64bcb4,783	///  or in textual repr: finishMinting()784	function finishMinting() public returns (bool) {785		require(false, stub_error);786		dummy = 0;787		return false;788	}789}790791/// @title Unique extensions for ERC721.792/// @dev the ERC-165 identifier for this interface is 0xb74c26b7793contract ERC721UniqueExtensions is Dummy, ERC165 {794	/// @notice A descriptive name for a collection of NFTs in this contract795	/// @dev EVM selector for this function is: 0x06fdde03,796	///  or in textual repr: name()797	function name() public view returns (string memory) {798		require(false, stub_error);799		dummy;800		return "";801	}802803	/// @notice An abbreviated name for NFTs in this contract804	/// @dev EVM selector for this function is: 0x95d89b41,805	///  or in textual repr: symbol()806	function symbol() public view returns (string memory) {807		require(false, stub_error);808		dummy;809		return "";810	}811812	/// @notice A description for the collection.813	/// @dev EVM selector for this function is: 0x7284e416,814	///  or in textual repr: description()815	function description() public view returns (string memory) {816		require(false, stub_error);817		dummy;818		return "";819	}820821	/// Returns the owner (in cross format) of the token.822	///823	/// @param tokenId Id for the token.824	/// @dev EVM selector for this function is: 0x2b29dace,825	///  or in textual repr: crossOwnerOf(uint256)826	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {827		require(false, stub_error);828		tokenId;829		dummy;830		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);831	}832833	/// Returns the token properties.834	///835	/// @param tokenId Id for the token.836	/// @param keys Properties keys. Empty keys for all propertyes.837	/// @return Vector of properties key/value pairs.838	/// @dev EVM selector for this function is: 0xe07ede7e,839	///  or in textual repr: properties(uint256,string[])840	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {841		require(false, stub_error);842		tokenId;843		keys;844		dummy;845		return new Property[](0);846	}847848	/// @notice Set or reaffirm the approved address for an NFT849	/// @dev The zero address indicates there is no approved address.850	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized851	///  operator of the current owner.852	/// @param approved The new substrate address approved NFT controller853	/// @param tokenId The NFT to approve854	/// @dev EVM selector for this function is: 0x0ecd0ab0,855	///  or in textual repr: approveCross((address,uint256),uint256)856	function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {857		require(false, stub_error);858		approved;859		tokenId;860		dummy = 0;861	}862863	/// @notice Transfer ownership of an NFT864	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`865	///  is the zero address. Throws if `tokenId` is not a valid NFT.866	/// @param to The new owner867	/// @param tokenId The NFT to transfer868	/// @dev EVM selector for this function is: 0xa9059cbb,869	///  or in textual repr: transfer(address,uint256)870	function transfer(address to, uint256 tokenId) public {871		require(false, stub_error);872		to;873		tokenId;874		dummy = 0;875	}876877	/// @notice Transfer ownership of an NFT878	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`879	///  is the zero address. Throws if `tokenId` is not a valid NFT.880	/// @param to The new owner881	/// @param tokenId The NFT to transfer882	/// @dev EVM selector for this function is: 0x2ada85ff,883	///  or in textual repr: transferCross((address,uint256),uint256)884	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {885		require(false, stub_error);886		to;887		tokenId;888		dummy = 0;889	}890891	/// @notice Transfer ownership of an NFT from cross account address to cross account address892	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`893	///  is the zero address. Throws if `tokenId` is not a valid NFT.894	/// @param from Cross acccount address of current owner895	/// @param to Cross acccount address of new owner896	/// @param tokenId The NFT to transfer897	/// @dev EVM selector for this function is: 0xd5cf430b,898	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)899	function transferFromCross(900		EthCrossAccount memory from,901		EthCrossAccount memory to,902		uint256 tokenId903	) public {904		require(false, stub_error);905		from;906		to;907		tokenId;908		dummy = 0;909	}910911	// /// @notice Burns a specific ERC721 token.912	// /// @dev Throws unless `msg.sender` is the current owner or an authorized913	// ///  operator for this NFT. Throws if `from` is not the current owner. Throws914	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.915	// /// @param from The current owner of the NFT916	// /// @param tokenId The NFT to transfer917	// /// @dev EVM selector for this function is: 0x79cc6790,918	// ///  or in textual repr: burnFrom(address,uint256)919	// function burnFrom(address from, uint256 tokenId) public {920	// 	require(false, stub_error);921	// 	from;922	// 	tokenId;923	// 	dummy = 0;924	// }925926	/// @notice Burns a specific ERC721 token.927	/// @dev Throws unless `msg.sender` is the current owner or an authorized928	///  operator for this NFT. Throws if `from` is not the current owner. Throws929	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.930	/// @param from The current owner of the NFT931	/// @param tokenId The NFT to transfer932	/// @dev EVM selector for this function is: 0xbb2f5a58,933	///  or in textual repr: burnFromCross((address,uint256),uint256)934	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {935		require(false, stub_error);936		from;937		tokenId;938		dummy = 0;939	}940941	/// @notice Returns next free NFT ID.942	/// @dev EVM selector for this function is: 0x75794a3c,943	///  or in textual repr: nextTokenId()944	function nextTokenId() public view returns (uint256) {945		require(false, stub_error);946		dummy;947		return 0;948	}949	// /// @notice Function to mint multiple tokens.950	// /// @dev `tokenIds` should be an array of consecutive numbers and first number951	// ///  should be obtained with `nextTokenId` method952	// /// @param to The new owner953	// /// @param tokenIds IDs of the minted NFTs954	// /// @dev EVM selector for this function is: 0x44a9945e,955	// ///  or in textual repr: mintBulk(address,uint256[])956	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {957	// 	require(false, stub_error);958	// 	to;959	// 	tokenIds;960	// 	dummy = 0;961	// 	return false;962	// }963964	// /// @notice Function to mint multiple tokens with the given tokenUris.965	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive966	// ///  numbers and first number should be obtained with `nextTokenId` method967	// /// @param to The new owner968	// /// @param tokens array of pairs of token ID and token URI for minted tokens969	// /// @dev EVM selector for this function is: 0x36543006,970	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])971	// function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {972	// 	require(false, stub_error);973	// 	to;974	// 	tokens;975	// 	dummy = 0;976	// 	return false;977	// }978979}980981/// @dev anonymous struct982struct Tuple15 {983	uint256 field_0;984	string field_1;985}986987/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension988/// @dev See https://eips.ethereum.org/EIPS/eip-721989/// @dev the ERC-165 identifier for this interface is 0x780e9d63990contract ERC721Enumerable is Dummy, ERC165 {991	/// @notice Enumerate valid NFTs992	/// @param index A counter less than `totalSupply()`993	/// @return The token identifier for the `index`th NFT,994	///  (sort order not specified)995	/// @dev EVM selector for this function is: 0x4f6ccce7,996	///  or in textual repr: tokenByIndex(uint256)997	function tokenByIndex(uint256 index) public view returns (uint256) {998		require(false, stub_error);999		index;1000		dummy;1001		return 0;1002	}10031004	/// @dev Not implemented1005	/// @dev EVM selector for this function is: 0x2f745c59,1006	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1007	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1008		require(false, stub_error);1009		owner;1010		index;1011		dummy;1012		return 0;1013	}10141015	/// @notice Count NFTs tracked by this contract1016	/// @return A count of valid NFTs tracked by this contract, where each one of1017	///  them has an assigned and queryable owner not equal to the zero address1018	/// @dev EVM selector for this function is: 0x18160ddd,1019	///  or in textual repr: totalSupply()1020	function totalSupply() public view returns (uint256) {1021		require(false, stub_error);1022		dummy;1023		return 0;1024	}1025}10261027/// @dev inlined interface1028contract ERC721Events {1029	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1030	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1031	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1032}10331034/// @title ERC-721 Non-Fungible Token Standard1035/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1036/// @dev the ERC-165 identifier for this interface is 0x983a942b1037contract ERC721 is Dummy, ERC165, ERC721Events {1038	/// @notice Count all NFTs assigned to an owner1039	/// @dev NFTs assigned to the zero address are considered invalid, and this1040	///  function throws for queries about the zero address.1041	/// @param owner An address for whom to query the balance1042	/// @return The number of NFTs owned by `owner`, possibly zero1043	/// @dev EVM selector for this function is: 0x70a08231,1044	///  or in textual repr: balanceOf(address)1045	function balanceOf(address owner) public view returns (uint256) {1046		require(false, stub_error);1047		owner;1048		dummy;1049		return 0;1050	}10511052	/// @notice Find the owner of an NFT1053	/// @dev NFTs assigned to zero address are considered invalid, and queries1054	///  about them do throw.1055	/// @param tokenId The identifier for an NFT1056	/// @return The address of the owner of the NFT1057	/// @dev EVM selector for this function is: 0x6352211e,1058	///  or in textual repr: ownerOf(uint256)1059	function ownerOf(uint256 tokenId) public view returns (address) {1060		require(false, stub_error);1061		tokenId;1062		dummy;1063		return 0x0000000000000000000000000000000000000000;1064	}10651066	/// @dev Not implemented1067	/// @dev EVM selector for this function is: 0xb88d4fde,1068	///  or in textual repr: safeTransferFrom(address,address,uint256,bytes)1069	function safeTransferFrom(1070		address from,1071		address to,1072		uint256 tokenId,1073		bytes memory data1074	) public {1075		require(false, stub_error);1076		from;1077		to;1078		tokenId;1079		data;1080		dummy = 0;1081	}10821083	/// @dev Not implemented1084	/// @dev EVM selector for this function is: 0x42842e0e,1085	///  or in textual repr: safeTransferFrom(address,address,uint256)1086	function safeTransferFrom(1087		address from,1088		address to,1089		uint256 tokenId1090	) public {1091		require(false, stub_error);1092		from;1093		to;1094		tokenId;1095		dummy = 0;1096	}10971098	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1099	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1100	///  THEY MAY BE PERMANENTLY LOST1101	/// @dev Throws unless `msg.sender` is the current owner or an authorized1102	///  operator for this NFT. Throws if `from` is not the current owner. Throws1103	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1104	/// @param from The current owner of the NFT1105	/// @param to The new owner1106	/// @param tokenId The NFT to transfer1107	/// @dev EVM selector for this function is: 0x23b872dd,1108	///  or in textual repr: transferFrom(address,address,uint256)1109	function transferFrom(1110		address from,1111		address to,1112		uint256 tokenId1113	) public {1114		require(false, stub_error);1115		from;1116		to;1117		tokenId;1118		dummy = 0;1119	}11201121	/// @notice Set or reaffirm the approved address for an NFT1122	/// @dev The zero address indicates there is no approved address.1123	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1124	///  operator of the current owner.1125	/// @param approved The new approved NFT controller1126	/// @param tokenId The NFT to approve1127	/// @dev EVM selector for this function is: 0x095ea7b3,1128	///  or in textual repr: approve(address,uint256)1129	function approve(address approved, uint256 tokenId) public {1130		require(false, stub_error);1131		approved;1132		tokenId;1133		dummy = 0;1134	}11351136	/// @notice Sets or unsets the approval of a given operator.1137	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1138	/// @param operator Operator1139	/// @param approved Should operator status be granted or revoked?1140	/// @dev EVM selector for this function is: 0xa22cb465,1141	///  or in textual repr: setApprovalForAll(address,bool)1142	function setApprovalForAll(address operator, bool approved) public {1143		require(false, stub_error);1144		operator;1145		approved;1146		dummy = 0;1147	}11481149	/// @dev Not implemented1150	/// @dev EVM selector for this function is: 0x081812fc,1151	///  or in textual repr: getApproved(uint256)1152	function getApproved(uint256 tokenId) public view returns (address) {1153		require(false, stub_error);1154		tokenId;1155		dummy;1156		return 0x0000000000000000000000000000000000000000;1157	}11581159	/// @notice Tells whether the given `owner` approves the `operator`.1160	/// @dev EVM selector for this function is: 0xe985e9c5,1161	///  or in textual repr: isApprovedForAll(address,address)1162	function isApprovedForAll(address owner, address operator) public view returns (bool) {1163		require(false, stub_error);1164		owner;1165		operator;1166		dummy;1167		return false;1168	}11691170	/// @notice Returns collection helper contract address1171	/// @dev EVM selector for this function is: 0x1896cce6,1172	///  or in textual repr: collectionHelperAddress()1173	function collectionHelperAddress() public view returns (address) {1174		require(false, stub_error);1175		dummy;1176		return 0x0000000000000000000000000000000000000000;1177	}1178}11791180contract UniqueNFT is1181	Dummy,1182	ERC165,1183	ERC721,1184	ERC721Enumerable,1185	ERC721UniqueExtensions,1186	ERC721UniqueMintable,1187	ERC721Burnable,1188	ERC721Metadata,1189	Collection,1190	TokenProperties1191{}