`176cbff9e8d3`

21 files changed

modifiedpallets/common/src/erc.rsdiff before after both

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -37,6 +37,7 @@
 	Pallet, CollectionHandle, Config, CollectionProperties, SelfWeightOf,
 	eth::{
 		EthCrossAccount, convert_cross_account_to_uint256, CollectionPermissions as EvmPermissions,
+		CollectionLimits as EvmCollectionLimits,
 	},
 	weights::WeightInfo,
 };
@@ -304,6 +305,99 @@
 		Ok(result)
 	}
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	fn collection_limits(&self) -> Result<Vec<(EvmCollectionLimits, bool, uint256)>> {
+		let convert_value_limit = |limit: EvmCollectionLimits,
+		                           value: Option<u32>|
+		 -> (EvmCollectionLimits, bool, uint256) {
+			value
+				.map(|v| (limit, true, v.into()))
+				.unwrap_or((limit, false, Default::default()))
+		};
+
+		let convert_bool_limit = |limit: EvmCollectionLimits,
+		                          value: Option<bool>|
+		 -> (EvmCollectionLimits, bool, uint256) {
+			value
+				.map(|v| {
+					(
+						limit,
+						true,
+						if v {
+							uint256::from(1)
+						} else {
+							Default::default()
+						},
+					)
+				})
+				.unwrap_or((limit, false, Default::default()))
+		};
+
+		let limits = &self.collection.limits;
+
+		Ok(vec![
+			convert_value_limit(
+				EvmCollectionLimits::AccountTokenOwnership,
+				limits.account_token_ownership_limit,
+			),
+			convert_value_limit(
+				EvmCollectionLimits::SponsoredDataSize,
+				limits.sponsored_data_size,
+			),
+			limits
+				.sponsored_data_rate_limit
+				.and_then(|limit| {
+					if let SponsoringRateLimit::Blocks(blocks) = limit {
+						Some((
+							EvmCollectionLimits::SponsoredDataRateLimit,
+							true,
+							blocks.into(),
+						))
+					} else {
+						None
+					}
+				})
+				.unwrap_or((
+					EvmCollectionLimits::SponsoredDataRateLimit,
+					false,
+					Default::default(),
+				)),
+			convert_value_limit(EvmCollectionLimits::TokenLimit, limits.token_limit),
+			convert_value_limit(
+				EvmCollectionLimits::SponsorTransferTimeout,
+				limits.sponsor_transfer_timeout,
+			),
+			convert_value_limit(
+				EvmCollectionLimits::SponsorApproveTimeout,
+				limits.sponsor_approve_timeout,
+			),
+			convert_bool_limit(
+				EvmCollectionLimits::OwnerCanTransfer,
+				limits.owner_can_transfer,
+			),
+			convert_bool_limit(
+				EvmCollectionLimits::OwnerCanDestroy,
+				limits.owner_can_destroy,
+			),
+			convert_bool_limit(
+				EvmCollectionLimits::TransferEnabled,
+				limits.transfers_enabled,
+			),
+		])
+	}
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -316,11 +410,22 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
 	#[solidity(rename_selector = "setCollectionLimit")]
-	fn set_int_limit(&mut self, caller: caller, limit: string, value: uint256) -> Result<void> {
+	fn set_collection_limit(
+		&mut self,
+		caller: caller,
+		limit: EvmCollectionLimits,
+		status: bool,
+		value: uint256,
+	) -> Result<void> {
 		self.consume_store_reads_and_writes(1, 1)?;
 
+		if !status {
+			return Err(Error::Revert("user can't disable limits".into()));
+		}
+
 		let value = value
 			.try_into()
 			.map_err(|_| Error::Revert(format!("can't convert value to u32 \"{}\"", value)))?;
@@ -338,35 +443,35 @@
 
 		let mut limits = self.limits.clone();
 
-		match limit.as_str() {
-			"accountTokenOwnershipLimit" => {
+		match limit {
+			EvmCollectionLimits::AccountTokenOwnership => {
 				limits.account_token_ownership_limit = Some(value);
 			}
-			"sponsoredDataSize" => {
+			EvmCollectionLimits::SponsoredDataSize => {
 				limits.sponsored_data_size = Some(value);
 			}
-			"sponsoredDataRateLimit" => {
+			EvmCollectionLimits::SponsoredDataRateLimit => {
 				limits.sponsored_data_rate_limit = Some(SponsoringRateLimit::Blocks(value));
 			}
-			"tokenLimit" => {
+			EvmCollectionLimits::TokenLimit => {
 				limits.token_limit = Some(value);
 			}
-			"sponsorTransferTimeout" => {
+			EvmCollectionLimits::SponsorTransferTimeout => {
 				limits.sponsor_transfer_timeout = Some(value);
 			}
-			"sponsorApproveTimeout" => {
+			EvmCollectionLimits::SponsorApproveTimeout => {
 				limits.sponsor_approve_timeout = Some(value);
 			}
-			"ownerCanTransfer" => {
+			EvmCollectionLimits::OwnerCanTransfer => {
 				limits.owner_can_transfer = Some(convert_value_to_bool()?);
 			}
-			"ownerCanDestroy" => {
+			EvmCollectionLimits::OwnerCanDestroy => {
 				limits.owner_can_destroy = Some(convert_value_to_bool()?);
 			}
-			"transfersEnabled" => {
+			EvmCollectionLimits::TransferEnabled => {
 				limits.transfers_enabled = Some(convert_value_to_bool()?);
 			}
-			_ => return Err(Error::Revert(format!("unknown limit \"{}\"", limit))),
+			_ => return Err(Error::Revert(format!("unknown limit \"{:?}\"", limit))),
 		}
 
 		let caller = T::CrossAccountId::from_eth(caller);

modifiedpallets/common/src/eth.rsdiff before after both

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -155,6 +155,31 @@
 		}
 	}
 }
+
+/// [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+#[derive(Debug, Default, Clone, Copy, AbiCoder)]
+#[repr(u8)]
+pub enum CollectionLimits {
+	/// How many tokens can a user have on one account.
+	#[default]
+	AccountTokenOwnership,
+	/// How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// How many tokens can be mined into this collection.
+	TokenLimit,
+	/// Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// Is it possible to send tokens from this collection between users.
+	TransferEnabled,
+}
 #[derive(Default, Debug, Clone, Copy, AbiCoder)]
 #[repr(u8)]
 pub enum CollectionPermissions {

modifiedpallets/fungible/src/stubs/UniqueFungible.rawdiff before after both

binary blob — no preview

modifiedpallets/fungible/src/stubs/UniqueFungible.soldiff before after both

--- a/pallets/fungible/src/stubs/UniqueFungible.sol
+++ b/pallets/fungible/src/stubs/UniqueFungible.sol
@@ -18,7 +18,7 @@
 }
 
 /// @title A contract that allows you to work with collections.
-/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
+/// @dev the ERC-165 identifier for this interface is 0x81172a75
 contract Collection is Dummy, ERC165 {
 	// /// Set collection property.
 	// ///
@@ -158,6 +158,27 @@
 		return Tuple8(0x0000000000000000000000000000000000000000, 0);
 	}
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	/// @dev EVM selector for this function is: 0xf63bc572,
+	///  or in textual repr: collectionLimits()
+	function collectionLimits() public view returns (Tuple20[] memory) {
+		require(false, stub_error);
+		dummy;
+		return new Tuple20[](0);
+	}
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -170,12 +191,18 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
-	/// @dev EVM selector for this function is: 0x4ad890a8,
-	///  or in textual repr: setCollectionLimit(string,uint256)
-	function setCollectionLimit(string memory limit, uint256 value) public {
+	/// @dev EVM selector for this function is: 0x88150bd0,
+	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)
+	function setCollectionLimit(
+		CollectionLimits limit,
+		bool status,
+		uint256 value
+	) public {
 		require(false, stub_error);
 		limit;
+		status;
 		value;
 		dummy = 0;
 	}
@@ -257,19 +284,19 @@
 	/// Returns nesting for a collection
 	/// @dev EVM selector for this function is: 0x22d25bfe,
 	///  or in textual repr: collectionNestingRestrictedCollectionIds()
-	function collectionNestingRestrictedCollectionIds() public view returns (Tuple21 memory) {
+	function collectionNestingRestrictedCollectionIds() public view returns (Tuple26 memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple21(false, new uint256[](0));
+		return Tuple26(false, new uint256[](0));
 	}
 
 	/// Returns permissions for a collection
 	/// @dev EVM selector for this function is: 0x5b2eaf4b,
 	///  or in textual repr: collectionNestingPermissions()
-	function collectionNestingPermissions() public view returns (Tuple24[] memory) {
+	function collectionNestingPermissions() public view returns (Tuple29[] memory) {
 		require(false, stub_error);
 		dummy;
-		return new Tuple24[](0);
+		return new Tuple29[](0);
 	}
 
 	/// Set the collection access method.
@@ -449,17 +476,46 @@
 }
 
 /// @dev anonymous struct
-struct Tuple24 {
+struct Tuple29 {
 	CollectionPermissions field_0;
 	bool field_1;
 }
 
 /// @dev anonymous struct
-struct Tuple21 {
+struct Tuple26 {
 	bool field_0;
 	uint256[] field_1;
 }
 
+/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+enum CollectionLimits {
+	/// @dev How many tokens can a user have on one account.
+	AccountTokenOwnership,
+	/// @dev How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// @dev How many tokens can be mined into this collection.
+	TokenLimit,
+	/// @dev Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// @dev Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// @dev Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// @dev Is it possible to send tokens from this collection between users.
+	TransferEnabled
+}
+
+/// @dev anonymous struct
+struct Tuple20 {
+	CollectionLimits field_0;
+	bool field_1;
+	uint256 field_2;
+}
+
 /// @dev Property struct
 struct Property {
 	string key;

modifiedpallets/nonfungible/src/stubs/UniqueNFT.rawdiff before after both

binary blob — no preview

modifiedpallets/nonfungible/src/stubs/UniqueNFT.soldiff before after both

--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -42,18 +42,19 @@
 	/// @param permissions Permissions for keys.
 	/// @dev EVM selector for this function is: 0xbd92983a,
 	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
-	function setTokenPropertyPermissions(Tuple48[] memory permissions) public {
+	function setTokenPropertyPermissions(Tuple59[] memory permissions) public {
 		require(false, stub_error);
 		permissions;
 		dummy = 0;
 	}
 
+	/// @notice Get permissions for token properties.
 	/// @dev EVM selector for this function is: 0xf23d7790,
 	///  or in textual repr: tokenPropertyPermissions()
-	function tokenPropertyPermissions() public view returns (Tuple48[] memory) {
+	function tokenPropertyPermissions() public view returns (Tuple59[] memory) {
 		require(false, stub_error);
 		dummy;
-		return new Tuple48[](0);
+		return new Tuple59[](0);
 	}
 
 	// /// @notice Set token property value.
@@ -132,26 +133,30 @@
 	bytes value;
 }
 
+/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.
 enum EthTokenPermissions {
+	/// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]
 	Mutable,
+	/// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]
 	TokenOwner,
+	/// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]
 	CollectionAdmin
 }
 
 /// @dev anonymous struct
-struct Tuple48 {
+struct Tuple59 {
 	string field_0;
-	Tuple46[] field_1;
+	Tuple57[] field_1;
 }
 
 /// @dev anonymous struct
-struct Tuple46 {
+struct Tuple57 {
 	EthTokenPermissions field_0;
 	bool field_1;
 }
 
 /// @title A contract that allows you to work with collections.
-/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
+/// @dev the ERC-165 identifier for this interface is 0x81172a75
 contract Collection is Dummy, ERC165 {
 	// /// Set collection property.
 	// ///
@@ -291,6 +296,27 @@
 		return Tuple30(0x0000000000000000000000000000000000000000, 0);
 	}
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	/// @dev EVM selector for this function is: 0xf63bc572,
+	///  or in textual repr: collectionLimits()
+	function collectionLimits() public view returns (Tuple33[] memory) {
+		require(false, stub_error);
+		dummy;
+		return new Tuple33[](0);
+	}
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -303,12 +329,18 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
-	/// @dev EVM selector for this function is: 0x4ad890a8,
-	///  or in textual repr: setCollectionLimit(string,uint256)
-	function setCollectionLimit(string memory limit, uint256 value) public {
+	/// @dev EVM selector for this function is: 0x88150bd0,
+	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)
+	function setCollectionLimit(
+		CollectionLimits limit,
+		bool status,
+		uint256 value
+	) public {
 		require(false, stub_error);
 		limit;
+		status;
 		value;
 		dummy = 0;
 	}
@@ -390,19 +422,19 @@
 	/// Returns nesting for a collection
 	/// @dev EVM selector for this function is: 0x22d25bfe,
 	///  or in textual repr: collectionNestingRestrictedCollectionIds()
-	function collectionNestingRestrictedCollectionIds() public view returns (Tuple34 memory) {
+	function collectionNestingRestrictedCollectionIds() public view returns (Tuple39 memory) {
 		require(false, stub_error);
 		dummy;
-		return Tuple34(false, new uint256[](0));
+		return Tuple39(false, new uint256[](0));
 	}
 
 	/// Returns permissions for a collection
 	/// @dev EVM selector for this function is: 0x5b2eaf4b,
 	///  or in textual repr: collectionNestingPermissions()
-	function collectionNestingPermissions() public view returns (Tuple37[] memory) {
+	function collectionNestingPermissions() public view returns (Tuple42[] memory) {
 		require(false, stub_error);
 		dummy;
-		return new Tuple37[](0);
+		return new Tuple42[](0);
 	}
 
 	/// Set the collection access method.
@@ -582,17 +614,46 @@
 }
 
 /// @dev anonymous struct
-struct Tuple37 {
+struct Tuple42 {
 	CollectionPermissions field_0;
 	bool field_1;
 }
 
 /// @dev anonymous struct
-struct Tuple34 {
+struct Tuple39 {
 	bool field_0;
 	uint256[] field_1;
 }
 
+/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+enum CollectionLimits {
+	/// @dev How many tokens can a user have on one account.
+	AccountTokenOwnership,
+	/// @dev How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// @dev How many tokens can be mined into this collection.
+	TokenLimit,
+	/// @dev Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// @dev Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// @dev Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// @dev Is it possible to send tokens from this collection between users.
+	TransferEnabled
+}
+
+/// @dev anonymous struct
+struct Tuple33 {
+	CollectionLimits field_0;
+	bool field_1;
+	uint256 field_2;
+}
+
 /// @dev anonymous struct
 struct Tuple30 {
 	address field_0;

modifiedpallets/refungible/src/stubs/UniqueRefungible.rawdiff before after both

binary blob — no preview

modifiedpallets/refungible/src/stubs/UniqueRefungible.soldiff before after both

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(Tuple53[] memory permissions) public {46		require(false, stub_error);47		permissions;48		dummy = 0;49	}5051	/// @notice Get permissions for token properties.52	/// @dev EVM selector for this function is: 0xf23d7790,53	///  or in textual repr: tokenPropertyPermissions()54	function tokenPropertyPermissions() public view returns (Tuple53[] memory) {55		require(false, stub_error);56		dummy;57		return new Tuple53[](0);58	}5960	// /// @notice Set token property value.61	// /// @dev Throws error if `msg.sender` has no permission to edit the property.62	// /// @param tokenId ID of the token.63	// /// @param key Property key.64	// /// @param value Property value.65	// /// @dev EVM selector for this function is: 0x1752d67b,66	// ///  or in textual repr: setProperty(uint256,string,bytes)67	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {68	// 	require(false, stub_error);69	// 	tokenId;70	// 	key;71	// 	value;72	// 	dummy = 0;73	// }7475	/// @notice Set token properties value.76	/// @dev Throws error if `msg.sender` has no permission to edit the property.77	/// @param tokenId ID of the token.78	/// @param properties settable properties79	/// @dev EVM selector for this function is: 0x14ed3a6e,80	///  or in textual repr: setProperties(uint256,(string,bytes)[])81	function setProperties(uint256 tokenId, Property[] memory properties) public {82		require(false, stub_error);83		tokenId;84		properties;85		dummy = 0;86	}8788	// /// @notice Delete token property value.89	// /// @dev Throws error if `msg.sender` has no permission to edit the property.90	// /// @param tokenId ID of the token.91	// /// @param key Property key.92	// /// @dev EVM selector for this function is: 0x066111d1,93	// ///  or in textual repr: deleteProperty(uint256,string)94	// function deleteProperty(uint256 tokenId, string memory key) public {95	// 	require(false, stub_error);96	// 	tokenId;97	// 	key;98	// 	dummy = 0;99	// }100101	/// @notice Delete token properties value.102	/// @dev Throws error if `msg.sender` has no permission to edit the property.103	/// @param tokenId ID of the token.104	/// @param keys Properties key.105	/// @dev EVM selector for this function is: 0xc472d371,106	///  or in textual repr: deleteProperties(uint256,string[])107	function deleteProperties(uint256 tokenId, string[] memory keys) public {108		require(false, stub_error);109		tokenId;110		keys;111		dummy = 0;112	}113114	/// @notice Get token property value.115	/// @dev Throws error if key not found116	/// @param tokenId ID of the token.117	/// @param key Property key.118	/// @return Property value bytes119	/// @dev EVM selector for this function is: 0x7228c327,120	///  or in textual repr: property(uint256,string)121	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {122		require(false, stub_error);123		tokenId;124		key;125		dummy;126		return hex"";127	}128}129130/// @dev Property struct131struct Property {132	string key;133	bytes value;134}135136enum EthTokenPermissions {137	Mutable,138	TokenOwner,139	CollectionAdmin140}141142/// @dev anonymous struct143struct Tuple53 {144	string field_0;145	Tuple51[] field_1;146}147148/// @dev anonymous struct149struct Tuple51 {150	EthTokenPermissions field_0;151	bool field_1;152}153154/// @title A contract that allows you to work with collections.155/// @dev the ERC-165 identifier for this interface is 0xb5e1747f156contract Collection is Dummy, ERC165 {157	// /// Set collection property.158	// ///159	// /// @param key Property key.160	// /// @param value Propery value.161	// /// @dev EVM selector for this function is: 0x2f073f66,162	// ///  or in textual repr: setCollectionProperty(string,bytes)163	// function setCollectionProperty(string memory key, bytes memory value) public {164	// 	require(false, stub_error);165	// 	key;166	// 	value;167	// 	dummy = 0;168	// }169170	/// Set collection properties.171	///172	/// @param properties Vector of properties key/value pair.173	/// @dev EVM selector for this function is: 0x50b26b2a,174	///  or in textual repr: setCollectionProperties((string,bytes)[])175	function setCollectionProperties(Property[] memory properties) public {176		require(false, stub_error);177		properties;178		dummy = 0;179	}180181	// /// Delete collection property.182	// ///183	// /// @param key Property key.184	// /// @dev EVM selector for this function is: 0x7b7debce,185	// ///  or in textual repr: deleteCollectionProperty(string)186	// function deleteCollectionProperty(string memory key) public {187	// 	require(false, stub_error);188	// 	key;189	// 	dummy = 0;190	// }191192	/// Delete collection properties.193	///194	/// @param keys Properties keys.195	/// @dev EVM selector for this function is: 0xee206ee3,196	///  or in textual repr: deleteCollectionProperties(string[])197	function deleteCollectionProperties(string[] memory keys) public {198		require(false, stub_error);199		keys;200		dummy = 0;201	}202203	/// Get collection property.204	///205	/// @dev Throws error if key not found.206	///207	/// @param key Property key.208	/// @return bytes The property corresponding to the key.209	/// @dev EVM selector for this function is: 0xcf24fd6d,210	///  or in textual repr: collectionProperty(string)211	function collectionProperty(string memory key) public view returns (bytes memory) {212		require(false, stub_error);213		key;214		dummy;215		return hex"";216	}217218	/// Get collection properties.219	///220	/// @param keys Properties keys. Empty keys for all propertyes.221	/// @return Vector of properties key/value pairs.222	/// @dev EVM selector for this function is: 0x285fb8e6,223	///  or in textual repr: collectionProperties(string[])224	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {225		require(false, stub_error);226		keys;227		dummy;228		return new Property[](0);229	}230231	// /// Set the sponsor of the collection.232	// ///233	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.234	// ///235	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.236	// /// @dev EVM selector for this function is: 0x7623402e,237	// ///  or in textual repr: setCollectionSponsor(address)238	// function setCollectionSponsor(address sponsor) public {239	// 	require(false, stub_error);240	// 	sponsor;241	// 	dummy = 0;242	// }243244	/// Set the sponsor of the collection.245	///246	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.247	///248	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.249	/// @dev EVM selector for this function is: 0x84a1d5a8,250	///  or in textual repr: setCollectionSponsorCross((address,uint256))251	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {252		require(false, stub_error);253		sponsor;254		dummy = 0;255	}256257	/// Whether there is a pending sponsor.258	/// @dev EVM selector for this function is: 0x058ac185,259	///  or in textual repr: hasCollectionPendingSponsor()260	function hasCollectionPendingSponsor() public view returns (bool) {261		require(false, stub_error);262		dummy;263		return false;264	}265266	/// Collection sponsorship confirmation.267	///268	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.269	/// @dev EVM selector for this function is: 0x3c50e97a,270	///  or in textual repr: confirmCollectionSponsorship()271	function confirmCollectionSponsorship() public {272		require(false, stub_error);273		dummy = 0;274	}275276	/// Remove collection sponsor.277	/// @dev EVM selector for this function is: 0x6e0326a3,278	///  or in textual repr: removeCollectionSponsor()279	function removeCollectionSponsor() public {280		require(false, stub_error);281		dummy = 0;282	}283284	/// Get current sponsor.285	///286	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.287	/// @dev EVM selector for this function is: 0x6ec0a9f1,288	///  or in textual repr: collectionSponsor()289	function collectionSponsor() public view returns (Tuple29 memory) {290		require(false, stub_error);291		dummy;292		return Tuple29(0x0000000000000000000000000000000000000000, 0);293	}294295	/// Set limits for the collection.296	/// @dev Throws error if limit not found.297	/// @param limit Name of the limit. Valid names:298	/// 	"accountTokenOwnershipLimit",299	/// 	"sponsoredDataSize",300	/// 	"sponsoredDataRateLimit",301	/// 	"tokenLimit",302	/// 	"sponsorTransferTimeout",303	/// 	"sponsorApproveTimeout"304	///  	"ownerCanTransfer",305	/// 	"ownerCanDestroy",306	/// 	"transfersEnabled"307	/// @param value Value of the limit.308	/// @dev EVM selector for this function is: 0x4ad890a8,309	///  or in textual repr: setCollectionLimit(string,uint256)310	function setCollectionLimit(string memory limit, uint256 value) public {311		require(false, stub_error);312		limit;313		value;314		dummy = 0;315	}316317	/// Get contract address.318	/// @dev EVM selector for this function is: 0xf6b4dfb4,319	///  or in textual repr: contractAddress()320	function contractAddress() public view returns (address) {321		require(false, stub_error);322		dummy;323		return 0x0000000000000000000000000000000000000000;324	}325326	/// Add collection admin.327	/// @param newAdmin Cross account administrator address.328	/// @dev EVM selector for this function is: 0x859aa7d6,329	///  or in textual repr: addCollectionAdminCross((address,uint256))330	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {331		require(false, stub_error);332		newAdmin;333		dummy = 0;334	}335336	/// Remove collection admin.337	/// @param admin Cross account administrator address.338	/// @dev EVM selector for this function is: 0x6c0cd173,339	///  or in textual repr: removeCollectionAdminCross((address,uint256))340	function removeCollectionAdminCross(EthCrossAccount memory admin) public {341		require(false, stub_error);342		admin;343		dummy = 0;344	}345346	// /// Add collection admin.347	// /// @param newAdmin Address of the added administrator.348	// /// @dev EVM selector for this function is: 0x92e462c7,349	// ///  or in textual repr: addCollectionAdmin(address)350	// function addCollectionAdmin(address newAdmin) public {351	// 	require(false, stub_error);352	// 	newAdmin;353	// 	dummy = 0;354	// }355356	// /// Remove collection admin.357	// ///358	// /// @param admin Address of the removed administrator.359	// /// @dev EVM selector for this function is: 0xfafd7b42,360	// ///  or in textual repr: removeCollectionAdmin(address)361	// function removeCollectionAdmin(address admin) public {362	// 	require(false, stub_error);363	// 	admin;364	// 	dummy = 0;365	// }366367	/// Toggle accessibility of collection nesting.368	///369	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'370	/// @dev EVM selector for this function is: 0x112d4586,371	///  or in textual repr: setCollectionNesting(bool)372	function setCollectionNesting(bool enable) public {373		require(false, stub_error);374		enable;375		dummy = 0;376	}377378	/// Toggle accessibility of collection nesting.379	///380	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'381	/// @param collections Addresses of collections that will be available for nesting.382	/// @dev EVM selector for this function is: 0x64872396,383	///  or in textual repr: setCollectionNesting(bool,address[])384	function setCollectionNesting(bool enable, address[] memory collections) public {385		require(false, stub_error);386		enable;387		collections;388		dummy = 0;389	}390391	/// Returns nesting for a collection392	/// @dev EVM selector for this function is: 0x22d25bfe,393	///  or in textual repr: collectionNestingRestrictedCollectionIds()394	function collectionNestingRestrictedCollectionIds() public view returns (Tuple33 memory) {395		require(false, stub_error);396		dummy;397		return Tuple33(false, new uint256[](0));398	}399400	/// Returns permissions for a collection401	/// @dev EVM selector for this function is: 0x5b2eaf4b,402	///  or in textual repr: collectionNestingPermissions()403	function collectionNestingPermissions() public view returns (Tuple36[] memory) {404		require(false, stub_error);405		dummy;406		return new Tuple36[](0);407	}408409	/// Set the collection access method.410	/// @param mode Access mode411	/// 	0 for Normal412	/// 	1 for AllowList413	/// @dev EVM selector for this function is: 0x41835d4c,414	///  or in textual repr: setCollectionAccess(uint8)415	function setCollectionAccess(uint8 mode) public {416		require(false, stub_error);417		mode;418		dummy = 0;419	}420421	/// Checks that user allowed to operate with collection.422	///423	/// @param user User address to check.424	/// @dev EVM selector for this function is: 0x91b6df49,425	///  or in textual repr: allowlistedCross((address,uint256))426	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {427		require(false, stub_error);428		user;429		dummy;430		return false;431	}432433	// /// Add the user to the allowed list.434	// ///435	// /// @param user Address of a trusted user.436	// /// @dev EVM selector for this function is: 0x67844fe6,437	// ///  or in textual repr: addToCollectionAllowList(address)438	// function addToCollectionAllowList(address user) public {439	// 	require(false, stub_error);440	// 	user;441	// 	dummy = 0;442	// }443444	/// Add user to allowed list.445	///446	/// @param user User cross account address.447	/// @dev EVM selector for this function is: 0xa0184a3a,448	///  or in textual repr: addToCollectionAllowListCross((address,uint256))449	function addToCollectionAllowListCross(EthCrossAccount memory user) public {450		require(false, stub_error);451		user;452		dummy = 0;453	}454455	// /// Remove the user from the allowed list.456	// ///457	// /// @param user Address of a removed user.458	// /// @dev EVM selector for this function is: 0x85c51acb,459	// ///  or in textual repr: removeFromCollectionAllowList(address)460	// function removeFromCollectionAllowList(address user) public {461	// 	require(false, stub_error);462	// 	user;463	// 	dummy = 0;464	// }465466	/// Remove user from allowed list.467	///468	/// @param user User cross account address.469	/// @dev EVM selector for this function is: 0x09ba452a,470	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))471	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {472		require(false, stub_error);473		user;474		dummy = 0;475	}476477	/// Switch permission for minting.478	///479	/// @param mode Enable if "true".480	/// @dev EVM selector for this function is: 0x00018e84,481	///  or in textual repr: setCollectionMintMode(bool)482	function setCollectionMintMode(bool mode) public {483		require(false, stub_error);484		mode;485		dummy = 0;486	}487488	// /// Check that account is the owner or admin of the collection489	// ///490	// /// @param user account to verify491	// /// @return "true" if account is the owner or admin492	// /// @dev EVM selector for this function is: 0x9811b0c7,493	// ///  or in textual repr: isOwnerOrAdmin(address)494	// function isOwnerOrAdmin(address user) public view returns (bool) {495	// 	require(false, stub_error);496	// 	user;497	// 	dummy;498	// 	return false;499	// }500501	/// Check that account is the owner or admin of the collection502	///503	/// @param user User cross account to verify504	/// @return "true" if account is the owner or admin505	/// @dev EVM selector for this function is: 0x3e75a905,506	///  or in textual repr: isOwnerOrAdminCross((address,uint256))507	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {508		require(false, stub_error);509		user;510		dummy;511		return false;512	}513514	/// Returns collection type515	///516	/// @return `Fungible` or `NFT` or `ReFungible`517	/// @dev EVM selector for this function is: 0xd34b55b8,518	///  or in textual repr: uniqueCollectionType()519	function uniqueCollectionType() public view returns (string memory) {520		require(false, stub_error);521		dummy;522		return "";523	}524525	/// Get collection owner.526	///527	/// @return Tuble with sponsor address and his substrate mirror.528	/// If address is canonical then substrate mirror is zero and vice versa.529	/// @dev EVM selector for this function is: 0xdf727d3b,530	///  or in textual repr: collectionOwner()531	function collectionOwner() public view returns (EthCrossAccount memory) {532		require(false, stub_error);533		dummy;534		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);535	}536537	// /// Changes collection owner to another account538	// ///539	// /// @dev Owner can be changed only by current owner540	// /// @param newOwner new owner account541	// /// @dev EVM selector for this function is: 0x4f53e226,542	// ///  or in textual repr: changeCollectionOwner(address)543	// function changeCollectionOwner(address newOwner) public {544	// 	require(false, stub_error);545	// 	newOwner;546	// 	dummy = 0;547	// }548549	/// Get collection administrators550	///551	/// @return Vector of tuples with admins address and his substrate mirror.552	/// If address is canonical then substrate mirror is zero and vice versa.553	/// @dev EVM selector for this function is: 0x5813216b,554	///  or in textual repr: collectionAdmins()555	function collectionAdmins() public view returns (EthCrossAccount[] memory) {556		require(false, stub_error);557		dummy;558		return new EthCrossAccount[](0);559	}560561	/// Changes collection owner to another account562	///563	/// @dev Owner can be changed only by current owner564	/// @param newOwner new owner cross account565	/// @dev EVM selector for this function is: 0x6496c497,566	///  or in textual repr: changeCollectionOwnerCross((address,uint256))567	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {568		require(false, stub_error);569		newOwner;570		dummy = 0;571	}572}573574/// @dev Cross account struct575struct EthCrossAccount {576	address eth;577	uint256 sub;578}579580enum CollectionPermissions {581	CollectionAdmin,582	TokenOwner583}584585/// @dev anonymous struct586struct Tuple36 {587	CollectionPermissions field_0;588	bool field_1;589}590591/// @dev anonymous struct592struct Tuple33 {593	bool field_0;594	uint256[] field_1;595}596597/// @dev anonymous struct598struct Tuple29 {599	address field_0;600	uint256 field_1;601}602603/// @dev the ERC-165 identifier for this interface is 0x5b5e139f604contract ERC721Metadata is Dummy, ERC165 {605	// /// @notice A descriptive name for a collection of NFTs in this contract606	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`607	// /// @dev EVM selector for this function is: 0x06fdde03,608	// ///  or in textual repr: name()609	// function name() public view returns (string memory) {610	// 	require(false, stub_error);611	// 	dummy;612	// 	return "";613	// }614615	// /// @notice An abbreviated name for NFTs in this contract616	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`617	// /// @dev EVM selector for this function is: 0x95d89b41,618	// ///  or in textual repr: symbol()619	// function symbol() public view returns (string memory) {620	// 	require(false, stub_error);621	// 	dummy;622	// 	return "";623	// }624625	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.626	///627	/// @dev If the token has a `url` property and it is not empty, it is returned.628	///  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`.629	///  If the collection property `baseURI` is empty or absent, return "" (empty string)630	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix631	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).632	///633	/// @return token's const_metadata634	/// @dev EVM selector for this function is: 0xc87b56dd,635	///  or in textual repr: tokenURI(uint256)636	function tokenURI(uint256 tokenId) public view returns (string memory) {637		require(false, stub_error);638		tokenId;639		dummy;640		return "";641	}642}643644/// @title ERC721 Token that can be irreversibly burned (destroyed).645/// @dev the ERC-165 identifier for this interface is 0x42966c68646contract ERC721Burnable is Dummy, ERC165 {647	/// @notice Burns a specific ERC721 token.648	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized649	///  operator of the current owner.650	/// @param tokenId The RFT to approve651	/// @dev EVM selector for this function is: 0x42966c68,652	///  or in textual repr: burn(uint256)653	function burn(uint256 tokenId) public {654		require(false, stub_error);655		tokenId;656		dummy = 0;657	}658}659660/// @dev inlined interface661contract ERC721UniqueMintableEvents {662	event MintingFinished();663}664665/// @title ERC721 minting logic.666/// @dev the ERC-165 identifier for this interface is 0x476ff149667contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {668	/// @dev EVM selector for this function is: 0x05d2035b,669	///  or in textual repr: mintingFinished()670	function mintingFinished() public view returns (bool) {671		require(false, stub_error);672		dummy;673		return false;674	}675676	/// @notice Function to mint token.677	/// @param to The new owner678	/// @return uint256 The id of the newly minted token679	/// @dev EVM selector for this function is: 0x6a627842,680	///  or in textual repr: mint(address)681	function mint(address to) public returns (uint256) {682		require(false, stub_error);683		to;684		dummy = 0;685		return 0;686	}687688	// /// @notice Function to mint token.689	// /// @dev `tokenId` should be obtained with `nextTokenId` method,690	// ///  unlike standard, you can't specify it manually691	// /// @param to The new owner692	// /// @param tokenId ID of the minted RFT693	// /// @dev EVM selector for this function is: 0x40c10f19,694	// ///  or in textual repr: mint(address,uint256)695	// function mint(address to, uint256 tokenId) public returns (bool) {696	// 	require(false, stub_error);697	// 	to;698	// 	tokenId;699	// 	dummy = 0;700	// 	return false;701	// }702703	/// @notice Function to mint token with the given tokenUri.704	/// @param to The new owner705	/// @param tokenUri Token URI that would be stored in the NFT properties706	/// @return uint256 The id of the newly minted token707	/// @dev EVM selector for this function is: 0x45c17782,708	///  or in textual repr: mintWithTokenURI(address,string)709	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {710		require(false, stub_error);711		to;712		tokenUri;713		dummy = 0;714		return 0;715	}716717	// /// @notice Function to mint token with the given tokenUri.718	// /// @dev `tokenId` should be obtained with `nextTokenId` method,719	// ///  unlike standard, you can't specify it manually720	// /// @param to The new owner721	// /// @param tokenId ID of the minted RFT722	// /// @param tokenUri Token URI that would be stored in the RFT properties723	// /// @dev EVM selector for this function is: 0x50bb4e7f,724	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)725	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {726	// 	require(false, stub_error);727	// 	to;728	// 	tokenId;729	// 	tokenUri;730	// 	dummy = 0;731	// 	return false;732	// }733734	/// @dev Not implemented735	/// @dev EVM selector for this function is: 0x7d64bcb4,736	///  or in textual repr: finishMinting()737	function finishMinting() public returns (bool) {738		require(false, stub_error);739		dummy = 0;740		return false;741	}742}743744/// @title Unique extensions for ERC721.745/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1746contract ERC721UniqueExtensions is Dummy, ERC165 {747	/// @notice A descriptive name for a collection of NFTs in this contract748	/// @dev EVM selector for this function is: 0x06fdde03,749	///  or in textual repr: name()750	function name() public view returns (string memory) {751		require(false, stub_error);752		dummy;753		return "";754	}755756	/// @notice An abbreviated name for NFTs in this contract757	/// @dev EVM selector for this function is: 0x95d89b41,758	///  or in textual repr: symbol()759	function symbol() public view returns (string memory) {760		require(false, stub_error);761		dummy;762		return "";763	}764765	/// @notice A description for the collection.766	/// @dev EVM selector for this function is: 0x7284e416,767	///  or in textual repr: description()768	function description() public view returns (string memory) {769		require(false, stub_error);770		dummy;771		return "";772	}773774	/// Returns the owner (in cross format) of the token.775	///776	/// @param tokenId Id for the token.777	/// @dev EVM selector for this function is: 0x2b29dace,778	///  or in textual repr: crossOwnerOf(uint256)779	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {780		require(false, stub_error);781		tokenId;782		dummy;783		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);784	}785786	/// Returns the token properties.787	///788	/// @param tokenId Id for the token.789	/// @param keys Properties keys. Empty keys for all propertyes.790	/// @return Vector of properties key/value pairs.791	/// @dev EVM selector for this function is: 0xe07ede7e,792	///  or in textual repr: properties(uint256,string[])793	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {794		require(false, stub_error);795		tokenId;796		keys;797		dummy;798		return new Property[](0);799	}800801	/// @notice Transfer ownership of an RFT802	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`803	///  is the zero address. Throws if `tokenId` is not a valid RFT.804	///  Throws if RFT pieces have multiple owners.805	/// @param to The new owner806	/// @param tokenId The RFT to transfer807	/// @dev EVM selector for this function is: 0xa9059cbb,808	///  or in textual repr: transfer(address,uint256)809	function transfer(address to, uint256 tokenId) public {810		require(false, stub_error);811		to;812		tokenId;813		dummy = 0;814	}815816	/// @notice Transfer ownership of an RFT817	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`818	///  is the zero address. Throws if `tokenId` is not a valid RFT.819	///  Throws if RFT pieces have multiple owners.820	/// @param to The new owner821	/// @param tokenId The RFT to transfer822	/// @dev EVM selector for this function is: 0x2ada85ff,823	///  or in textual repr: transferCross((address,uint256),uint256)824	function transferCross(EthCrossAccount memory to, uint256 tokenId) public {825		require(false, stub_error);826		to;827		tokenId;828		dummy = 0;829	}830831	/// @notice Transfer ownership of an RFT832	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`833	///  is the zero address. Throws if `tokenId` is not a valid RFT.834	///  Throws if RFT pieces have multiple owners.835	/// @param to The new owner836	/// @param tokenId The RFT to transfer837	/// @dev EVM selector for this function is: 0xd5cf430b,838	///  or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)839	function transferFromCross(840		EthCrossAccount memory from,841		EthCrossAccount memory to,842		uint256 tokenId843	) public {844		require(false, stub_error);845		from;846		to;847		tokenId;848		dummy = 0;849	}850851	// /// @notice Burns a specific ERC721 token.852	// /// @dev Throws unless `msg.sender` is the current owner or an authorized853	// ///  operator for this RFT. Throws if `from` is not the current owner. Throws854	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.855	// ///  Throws if RFT pieces have multiple owners.856	// /// @param from The current owner of the RFT857	// /// @param tokenId The RFT to transfer858	// /// @dev EVM selector for this function is: 0x79cc6790,859	// ///  or in textual repr: burnFrom(address,uint256)860	// function burnFrom(address from, uint256 tokenId) public {861	// 	require(false, stub_error);862	// 	from;863	// 	tokenId;864	// 	dummy = 0;865	// }866867	/// @notice Burns a specific ERC721 token.868	/// @dev Throws unless `msg.sender` is the current owner or an authorized869	///  operator for this RFT. Throws if `from` is not the current owner. Throws870	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.871	///  Throws if RFT pieces have multiple owners.872	/// @param from The current owner of the RFT873	/// @param tokenId The RFT to transfer874	/// @dev EVM selector for this function is: 0xbb2f5a58,875	///  or in textual repr: burnFromCross((address,uint256),uint256)876	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {877		require(false, stub_error);878		from;879		tokenId;880		dummy = 0;881	}882883	/// @notice Returns next free RFT ID.884	/// @dev EVM selector for this function is: 0x75794a3c,885	///  or in textual repr: nextTokenId()886	function nextTokenId() public view returns (uint256) {887		require(false, stub_error);888		dummy;889		return 0;890	}891892	// /// @notice Function to mint multiple tokens.893	// /// @dev `tokenIds` should be an array of consecutive numbers and first number894	// ///  should be obtained with `nextTokenId` method895	// /// @param to The new owner896	// /// @param tokenIds IDs of the minted RFTs897	// /// @dev EVM selector for this function is: 0x44a9945e,898	// ///  or in textual repr: mintBulk(address,uint256[])899	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {900	// 	require(false, stub_error);901	// 	to;902	// 	tokenIds;903	// 	dummy = 0;904	// 	return false;905	// }906907	// /// @notice Function to mint multiple tokens with the given tokenUris.908	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive909	// ///  numbers and first number should be obtained with `nextTokenId` method910	// /// @param to The new owner911	// /// @param tokens array of pairs of token ID and token URI for minted tokens912	// /// @dev EVM selector for this function is: 0x36543006,913	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])914	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {915	// 	require(false, stub_error);916	// 	to;917	// 	tokens;918	// 	dummy = 0;919	// 	return false;920	// }921922	/// Returns EVM address for refungible token923	///924	/// @param token ID of the token925	/// @dev EVM selector for this function is: 0xab76fac6,926	///  or in textual repr: tokenContractAddress(uint256)927	function tokenContractAddress(uint256 token) public view returns (address) {928		require(false, stub_error);929		token;930		dummy;931		return 0x0000000000000000000000000000000000000000;932	}933}934935/// @dev anonymous struct936struct Tuple14 {937	uint256 field_0;938	string field_1;939}940941/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension942/// @dev See https://eips.ethereum.org/EIPS/eip-721943/// @dev the ERC-165 identifier for this interface is 0x780e9d63944contract ERC721Enumerable is Dummy, ERC165 {945	/// @notice Enumerate valid RFTs946	/// @param index A counter less than `totalSupply()`947	/// @return The token identifier for the `index`th NFT,948	///  (sort order not specified)949	/// @dev EVM selector for this function is: 0x4f6ccce7,950	///  or in textual repr: tokenByIndex(uint256)951	function tokenByIndex(uint256 index) public view returns (uint256) {952		require(false, stub_error);953		index;954		dummy;955		return 0;956	}957958	/// Not implemented959	/// @dev EVM selector for this function is: 0x2f745c59,960	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)961	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {962		require(false, stub_error);963		owner;964		index;965		dummy;966		return 0;967	}968969	/// @notice Count RFTs tracked by this contract970	/// @return A count of valid RFTs tracked by this contract, where each one of971	///  them has an assigned and queryable owner not equal to the zero address972	/// @dev EVM selector for this function is: 0x18160ddd,973	///  or in textual repr: totalSupply()974	function totalSupply() public view returns (uint256) {975		require(false, stub_error);976		dummy;977		return 0;978	}979}980981/// @dev inlined interface982contract ERC721Events {983	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);984	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);985	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);986}987988/// @title ERC-721 Non-Fungible Token Standard989/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md990/// @dev the ERC-165 identifier for this interface is 0x4016cd87991contract ERC721 is Dummy, ERC165, ERC721Events {992	/// @notice Count all RFTs assigned to an owner993	/// @dev RFTs assigned to the zero address are considered invalid, and this994	///  function throws for queries about the zero address.995	/// @param owner An address for whom to query the balance996	/// @return The number of RFTs owned by `owner`, possibly zero997	/// @dev EVM selector for this function is: 0x70a08231,998	///  or in textual repr: balanceOf(address)999	function balanceOf(address owner) public view returns (uint256) {1000		require(false, stub_error);1001		owner;1002		dummy;1003		return 0;1004	}10051006	/// @notice Find the owner of an RFT1007	/// @dev RFTs assigned to zero address are considered invalid, and queries1008	///  about them do throw.1009	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1010	///  the tokens that are partially owned.1011	/// @param tokenId The identifier for an RFT1012	/// @return The address of the owner of the RFT1013	/// @dev EVM selector for this function is: 0x6352211e,1014	///  or in textual repr: ownerOf(uint256)1015	function ownerOf(uint256 tokenId) public view returns (address) {1016		require(false, stub_error);1017		tokenId;1018		dummy;1019		return 0x0000000000000000000000000000000000000000;1020	}10211022	/// @dev Not implemented1023	/// @dev EVM selector for this function is: 0x60a11672,1024	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)1025	function safeTransferFromWithData(1026		address from,1027		address to,1028		uint256 tokenId,1029		bytes memory data1030	) public {1031		require(false, stub_error);1032		from;1033		to;1034		tokenId;1035		data;1036		dummy = 0;1037	}10381039	/// @dev Not implemented1040	/// @dev EVM selector for this function is: 0x42842e0e,1041	///  or in textual repr: safeTransferFrom(address,address,uint256)1042	function safeTransferFrom(1043		address from,1044		address to,1045		uint256 tokenId1046	) public {1047		require(false, stub_error);1048		from;1049		to;1050		tokenId;1051		dummy = 0;1052	}10531054	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1055	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1056	///  THEY MAY BE PERMANENTLY LOST1057	/// @dev Throws unless `msg.sender` is the current owner or an authorized1058	///  operator for this RFT. Throws if `from` is not the current owner. Throws1059	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1060	///  Throws if RFT pieces have multiple owners.1061	/// @param from The current owner of the NFT1062	/// @param to The new owner1063	/// @param tokenId The NFT to transfer1064	/// @dev EVM selector for this function is: 0x23b872dd,1065	///  or in textual repr: transferFrom(address,address,uint256)1066	function transferFrom(1067		address from,1068		address to,1069		uint256 tokenId1070	) public {1071		require(false, stub_error);1072		from;1073		to;1074		tokenId;1075		dummy = 0;1076	}10771078	/// @dev Not implemented1079	/// @dev EVM selector for this function is: 0x095ea7b3,1080	///  or in textual repr: approve(address,uint256)1081	function approve(address approved, uint256 tokenId) public {1082		require(false, stub_error);1083		approved;1084		tokenId;1085		dummy = 0;1086	}10871088	/// @notice Sets or unsets the approval of a given operator.1089	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1090	/// @param operator Operator1091	/// @param approved Should operator status be granted or revoked?1092	/// @dev EVM selector for this function is: 0xa22cb465,1093	///  or in textual repr: setApprovalForAll(address,bool)1094	function setApprovalForAll(address operator, bool approved) public {1095		require(false, stub_error);1096		operator;1097		approved;1098		dummy = 0;1099	}11001101	/// @dev Not implemented1102	/// @dev EVM selector for this function is: 0x081812fc,1103	///  or in textual repr: getApproved(uint256)1104	function getApproved(uint256 tokenId) public view returns (address) {1105		require(false, stub_error);1106		tokenId;1107		dummy;1108		return 0x0000000000000000000000000000000000000000;1109	}11101111	/// @notice Tells whether the given `owner` approves the `operator`.1112	/// @dev EVM selector for this function is: 0xe985e9c5,1113	///  or in textual repr: isApprovedForAll(address,address)1114	function isApprovedForAll(address owner, address operator) public view returns (bool) {1115		require(false, stub_error);1116		owner;1117		operator;1118		dummy;1119		return false;1120	}11211122	/// @notice Returns collection helper contract address1123	/// @dev EVM selector for this function is: 0x1896cce6,1124	///  or in textual repr: collectionHelperAddress()1125	function collectionHelperAddress() public view returns (address) {1126		require(false, stub_error);1127		dummy;1128		return 0x0000000000000000000000000000000000000000;1129	}1130}11311132contract UniqueRefungible is1133	Dummy,1134	ERC165,1135	ERC721,1136	ERC721Enumerable,1137	ERC721UniqueExtensions,1138	ERC721UniqueMintable,1139	ERC721Burnable,1140	ERC721Metadata,1141	Collection,1142	TokenProperties1143{}

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(Tuple58[] memory permissions) public {46		require(false, stub_error);47		permissions;48		dummy = 0;49	}5051	/// @notice Get permissions for token properties.52	/// @dev EVM selector for this function is: 0xf23d7790,53	///  or in textual repr: tokenPropertyPermissions()54	function tokenPropertyPermissions() public view returns (Tuple58[] memory) {55		require(false, stub_error);56		dummy;57		return new Tuple58[](0);58	}5960	// /// @notice Set token property value.61	// /// @dev Throws error if `msg.sender` has no permission to edit the property.62	// /// @param tokenId ID of the token.63	// /// @param key Property key.64	// /// @param value Property value.65	// /// @dev EVM selector for this function is: 0x1752d67b,66	// ///  or in textual repr: setProperty(uint256,string,bytes)67	// function setProperty(uint256 tokenId, string memory key, bytes memory value) public {68	// 	require(false, stub_error);69	// 	tokenId;70	// 	key;71	// 	value;72	// 	dummy = 0;73	// }7475	/// @notice Set token properties value.76	/// @dev Throws error if `msg.sender` has no permission to edit the property.77	/// @param tokenId ID of the token.78	/// @param properties settable properties79	/// @dev EVM selector for this function is: 0x14ed3a6e,80	///  or in textual repr: setProperties(uint256,(string,bytes)[])81	function setProperties(uint256 tokenId, Property[] memory properties) public {82		require(false, stub_error);83		tokenId;84		properties;85		dummy = 0;86	}8788	// /// @notice Delete token property value.89	// /// @dev Throws error if `msg.sender` has no permission to edit the property.90	// /// @param tokenId ID of the token.91	// /// @param key Property key.92	// /// @dev EVM selector for this function is: 0x066111d1,93	// ///  or in textual repr: deleteProperty(uint256,string)94	// function deleteProperty(uint256 tokenId, string memory key) public {95	// 	require(false, stub_error);96	// 	tokenId;97	// 	key;98	// 	dummy = 0;99	// }100101	/// @notice Delete token properties value.102	/// @dev Throws error if `msg.sender` has no permission to edit the property.103	/// @param tokenId ID of the token.104	/// @param keys Properties key.105	/// @dev EVM selector for this function is: 0xc472d371,106	///  or in textual repr: deleteProperties(uint256,string[])107	function deleteProperties(uint256 tokenId, string[] memory keys) public {108		require(false, stub_error);109		tokenId;110		keys;111		dummy = 0;112	}113114	/// @notice Get token property value.115	/// @dev Throws error if key not found116	/// @param tokenId ID of the token.117	/// @param key Property key.118	/// @return Property value bytes119	/// @dev EVM selector for this function is: 0x7228c327,120	///  or in textual repr: property(uint256,string)121	function property(uint256 tokenId, string memory key) public view returns (bytes memory) {122		require(false, stub_error);123		tokenId;124		key;125		dummy;126		return hex"";127	}128}129130/// @dev Property struct131struct Property {132	string key;133	bytes value;134}135136/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.137enum EthTokenPermissions {138	/// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]139	Mutable,140	/// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]141	TokenOwner,142	/// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]143	CollectionAdmin144}145146/// @dev anonymous struct147struct Tuple58 {148	string field_0;149	Tuple56[] field_1;150}151152/// @dev anonymous struct153struct Tuple56 {154	EthTokenPermissions field_0;155	bool field_1;156}157158/// @title A contract that allows you to work with collections.159/// @dev the ERC-165 identifier for this interface is 0x81172a75160contract Collection is Dummy, ERC165 {161	// /// Set collection property.162	// ///163	// /// @param key Property key.164	// /// @param value Propery value.165	// /// @dev EVM selector for this function is: 0x2f073f66,166	// ///  or in textual repr: setCollectionProperty(string,bytes)167	// function setCollectionProperty(string memory key, bytes memory value) public {168	// 	require(false, stub_error);169	// 	key;170	// 	value;171	// 	dummy = 0;172	// }173174	/// Set collection properties.175	///176	/// @param properties Vector of properties key/value pair.177	/// @dev EVM selector for this function is: 0x50b26b2a,178	///  or in textual repr: setCollectionProperties((string,bytes)[])179	function setCollectionProperties(Property[] memory properties) public {180		require(false, stub_error);181		properties;182		dummy = 0;183	}184185	// /// Delete collection property.186	// ///187	// /// @param key Property key.188	// /// @dev EVM selector for this function is: 0x7b7debce,189	// ///  or in textual repr: deleteCollectionProperty(string)190	// function deleteCollectionProperty(string memory key) public {191	// 	require(false, stub_error);192	// 	key;193	// 	dummy = 0;194	// }195196	/// Delete collection properties.197	///198	/// @param keys Properties keys.199	/// @dev EVM selector for this function is: 0xee206ee3,200	///  or in textual repr: deleteCollectionProperties(string[])201	function deleteCollectionProperties(string[] memory keys) public {202		require(false, stub_error);203		keys;204		dummy = 0;205	}206207	/// Get collection property.208	///209	/// @dev Throws error if key not found.210	///211	/// @param key Property key.212	/// @return bytes The property corresponding to the key.213	/// @dev EVM selector for this function is: 0xcf24fd6d,214	///  or in textual repr: collectionProperty(string)215	function collectionProperty(string memory key) public view returns (bytes memory) {216		require(false, stub_error);217		key;218		dummy;219		return hex"";220	}221222	/// Get collection properties.223	///224	/// @param keys Properties keys. Empty keys for all propertyes.225	/// @return Vector of properties key/value pairs.226	/// @dev EVM selector for this function is: 0x285fb8e6,227	///  or in textual repr: collectionProperties(string[])228	function collectionProperties(string[] memory keys) public view returns (Property[] memory) {229		require(false, stub_error);230		keys;231		dummy;232		return new Property[](0);233	}234235	// /// Set the sponsor of the collection.236	// ///237	// /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.238	// ///239	// /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.240	// /// @dev EVM selector for this function is: 0x7623402e,241	// ///  or in textual repr: setCollectionSponsor(address)242	// function setCollectionSponsor(address sponsor) public {243	// 	require(false, stub_error);244	// 	sponsor;245	// 	dummy = 0;246	// }247248	/// Set the sponsor of the collection.249	///250	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.251	///252	/// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.253	/// @dev EVM selector for this function is: 0x84a1d5a8,254	///  or in textual repr: setCollectionSponsorCross((address,uint256))255	function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {256		require(false, stub_error);257		sponsor;258		dummy = 0;259	}260261	/// Whether there is a pending sponsor.262	/// @dev EVM selector for this function is: 0x058ac185,263	///  or in textual repr: hasCollectionPendingSponsor()264	function hasCollectionPendingSponsor() public view returns (bool) {265		require(false, stub_error);266		dummy;267		return false;268	}269270	/// Collection sponsorship confirmation.271	///272	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.273	/// @dev EVM selector for this function is: 0x3c50e97a,274	///  or in textual repr: confirmCollectionSponsorship()275	function confirmCollectionSponsorship() public {276		require(false, stub_error);277		dummy = 0;278	}279280	/// Remove collection sponsor.281	/// @dev EVM selector for this function is: 0x6e0326a3,282	///  or in textual repr: removeCollectionSponsor()283	function removeCollectionSponsor() public {284		require(false, stub_error);285		dummy = 0;286	}287288	/// Get current sponsor.289	///290	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.291	/// @dev EVM selector for this function is: 0x6ec0a9f1,292	///  or in textual repr: collectionSponsor()293	function collectionSponsor() public view returns (Tuple29 memory) {294		require(false, stub_error);295		dummy;296		return Tuple29(0x0000000000000000000000000000000000000000, 0);297	}298299	/// Get current collection limits.300	///301	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:302	/// 	"accountTokenOwnershipLimit",303	/// 	"sponsoredDataSize",304	/// 	"sponsoredDataRateLimit",305	/// 	"tokenLimit",306	/// 	"sponsorTransferTimeout",307	/// 	"sponsorApproveTimeout"308	///  	"ownerCanTransfer",309	/// 	"ownerCanDestroy",310	/// 	"transfersEnabled"311	/// Return `false` if a limit not set.312	/// @dev EVM selector for this function is: 0xf63bc572,313	///  or in textual repr: collectionLimits()314	function collectionLimits() public view returns (Tuple32[] memory) {315		require(false, stub_error);316		dummy;317		return new Tuple32[](0);318	}319320	/// Set limits for the collection.321	/// @dev Throws error if limit not found.322	/// @param limit Name of the limit. Valid names:323	/// 	"accountTokenOwnershipLimit",324	/// 	"sponsoredDataSize",325	/// 	"sponsoredDataRateLimit",326	/// 	"tokenLimit",327	/// 	"sponsorTransferTimeout",328	/// 	"sponsorApproveTimeout"329	///  	"ownerCanTransfer",330	/// 	"ownerCanDestroy",331	/// 	"transfersEnabled"332	/// @param status enable\disable limit. Works only with `true`.333	/// @param value Value of the limit.334	/// @dev EVM selector for this function is: 0x88150bd0,335	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)336	function setCollectionLimit(337		CollectionLimits limit,338		bool status,339		uint256 value340	) public {341		require(false, stub_error);342		limit;343		status;344		value;345		dummy = 0;346	}347348	/// Get contract address.349	/// @dev EVM selector for this function is: 0xf6b4dfb4,350	///  or in textual repr: contractAddress()351	function contractAddress() public view returns (address) {352		require(false, stub_error);353		dummy;354		return 0x0000000000000000000000000000000000000000;355	}356357	/// Add collection admin.358	/// @param newAdmin Cross account administrator address.359	/// @dev EVM selector for this function is: 0x859aa7d6,360	///  or in textual repr: addCollectionAdminCross((address,uint256))361	function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {362		require(false, stub_error);363		newAdmin;364		dummy = 0;365	}366367	/// Remove collection admin.368	/// @param admin Cross account administrator address.369	/// @dev EVM selector for this function is: 0x6c0cd173,370	///  or in textual repr: removeCollectionAdminCross((address,uint256))371	function removeCollectionAdminCross(EthCrossAccount memory admin) public {372		require(false, stub_error);373		admin;374		dummy = 0;375	}376377	// /// Add collection admin.378	// /// @param newAdmin Address of the added administrator.379	// /// @dev EVM selector for this function is: 0x92e462c7,380	// ///  or in textual repr: addCollectionAdmin(address)381	// function addCollectionAdmin(address newAdmin) public {382	// 	require(false, stub_error);383	// 	newAdmin;384	// 	dummy = 0;385	// }386387	// /// Remove collection admin.388	// ///389	// /// @param admin Address of the removed administrator.390	// /// @dev EVM selector for this function is: 0xfafd7b42,391	// ///  or in textual repr: removeCollectionAdmin(address)392	// function removeCollectionAdmin(address admin) public {393	// 	require(false, stub_error);394	// 	admin;395	// 	dummy = 0;396	// }397398	/// Toggle accessibility of collection nesting.399	///400	/// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'401	/// @dev EVM selector for this function is: 0x112d4586,402	///  or in textual repr: setCollectionNesting(bool)403	function setCollectionNesting(bool enable) public {404		require(false, stub_error);405		enable;406		dummy = 0;407	}408409	/// Toggle accessibility of collection nesting.410	///411	/// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'412	/// @param collections Addresses of collections that will be available for nesting.413	/// @dev EVM selector for this function is: 0x64872396,414	///  or in textual repr: setCollectionNesting(bool,address[])415	function setCollectionNesting(bool enable, address[] memory collections) public {416		require(false, stub_error);417		enable;418		collections;419		dummy = 0;420	}421422	/// Returns nesting for a collection423	/// @dev EVM selector for this function is: 0x22d25bfe,424	///  or in textual repr: collectionNestingRestrictedCollectionIds()425	function collectionNestingRestrictedCollectionIds() public view returns (Tuple38 memory) {426		require(false, stub_error);427		dummy;428		return Tuple38(false, new uint256[](0));429	}430431	/// Returns permissions for a collection432	/// @dev EVM selector for this function is: 0x5b2eaf4b,433	///  or in textual repr: collectionNestingPermissions()434	function collectionNestingPermissions() public view returns (Tuple41[] memory) {435		require(false, stub_error);436		dummy;437		return new Tuple41[](0);438	}439440	/// Set the collection access method.441	/// @param mode Access mode442	/// 	0 for Normal443	/// 	1 for AllowList444	/// @dev EVM selector for this function is: 0x41835d4c,445	///  or in textual repr: setCollectionAccess(uint8)446	function setCollectionAccess(uint8 mode) public {447		require(false, stub_error);448		mode;449		dummy = 0;450	}451452	/// Checks that user allowed to operate with collection.453	///454	/// @param user User address to check.455	/// @dev EVM selector for this function is: 0x91b6df49,456	///  or in textual repr: allowlistedCross((address,uint256))457	function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {458		require(false, stub_error);459		user;460		dummy;461		return false;462	}463464	// /// Add the user to the allowed list.465	// ///466	// /// @param user Address of a trusted user.467	// /// @dev EVM selector for this function is: 0x67844fe6,468	// ///  or in textual repr: addToCollectionAllowList(address)469	// function addToCollectionAllowList(address user) public {470	// 	require(false, stub_error);471	// 	user;472	// 	dummy = 0;473	// }474475	/// Add user to allowed list.476	///477	/// @param user User cross account address.478	/// @dev EVM selector for this function is: 0xa0184a3a,479	///  or in textual repr: addToCollectionAllowListCross((address,uint256))480	function addToCollectionAllowListCross(EthCrossAccount memory user) public {481		require(false, stub_error);482		user;483		dummy = 0;484	}485486	// /// Remove the user from the allowed list.487	// ///488	// /// @param user Address of a removed user.489	// /// @dev EVM selector for this function is: 0x85c51acb,490	// ///  or in textual repr: removeFromCollectionAllowList(address)491	// function removeFromCollectionAllowList(address user) public {492	// 	require(false, stub_error);493	// 	user;494	// 	dummy = 0;495	// }496497	/// Remove user from allowed list.498	///499	/// @param user User cross account address.500	/// @dev EVM selector for this function is: 0x09ba452a,501	///  or in textual repr: removeFromCollectionAllowListCross((address,uint256))502	function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {503		require(false, stub_error);504		user;505		dummy = 0;506	}507508	/// Switch permission for minting.509	///510	/// @param mode Enable if "true".511	/// @dev EVM selector for this function is: 0x00018e84,512	///  or in textual repr: setCollectionMintMode(bool)513	function setCollectionMintMode(bool mode) public {514		require(false, stub_error);515		mode;516		dummy = 0;517	}518519	// /// Check that account is the owner or admin of the collection520	// ///521	// /// @param user account to verify522	// /// @return "true" if account is the owner or admin523	// /// @dev EVM selector for this function is: 0x9811b0c7,524	// ///  or in textual repr: isOwnerOrAdmin(address)525	// function isOwnerOrAdmin(address user) public view returns (bool) {526	// 	require(false, stub_error);527	// 	user;528	// 	dummy;529	// 	return false;530	// }531532	/// Check that account is the owner or admin of the collection533	///534	/// @param user User cross account to verify535	/// @return "true" if account is the owner or admin536	/// @dev EVM selector for this function is: 0x3e75a905,537	///  or in textual repr: isOwnerOrAdminCross((address,uint256))538	function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {539		require(false, stub_error);540		user;541		dummy;542		return false;543	}544545	/// Returns collection type546	///547	/// @return `Fungible` or `NFT` or `ReFungible`548	/// @dev EVM selector for this function is: 0xd34b55b8,549	///  or in textual repr: uniqueCollectionType()550	function uniqueCollectionType() public view returns (string memory) {551		require(false, stub_error);552		dummy;553		return "";554	}555556	/// Get collection owner.557	///558	/// @return Tuble with sponsor address and his substrate mirror.559	/// If address is canonical then substrate mirror is zero and vice versa.560	/// @dev EVM selector for this function is: 0xdf727d3b,561	///  or in textual repr: collectionOwner()562	function collectionOwner() public view returns (EthCrossAccount memory) {563		require(false, stub_error);564		dummy;565		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);566	}567568	// /// Changes collection owner to another account569	// ///570	// /// @dev Owner can be changed only by current owner571	// /// @param newOwner new owner account572	// /// @dev EVM selector for this function is: 0x4f53e226,573	// ///  or in textual repr: changeCollectionOwner(address)574	// function changeCollectionOwner(address newOwner) public {575	// 	require(false, stub_error);576	// 	newOwner;577	// 	dummy = 0;578	// }579580	/// Get collection administrators581	///582	/// @return Vector of tuples with admins address and his substrate mirror.583	/// If address is canonical then substrate mirror is zero and vice versa.584	/// @dev EVM selector for this function is: 0x5813216b,585	///  or in textual repr: collectionAdmins()586	function collectionAdmins() public view returns (EthCrossAccount[] memory) {587		require(false, stub_error);588		dummy;589		return new EthCrossAccount[](0);590	}591592	/// Changes collection owner to another account593	///594	/// @dev Owner can be changed only by current owner595	/// @param newOwner new owner cross account596	/// @dev EVM selector for this function is: 0x6496c497,597	///  or in textual repr: changeCollectionOwnerCross((address,uint256))598	function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {599		require(false, stub_error);600		newOwner;601		dummy = 0;602	}603}604605/// @dev Cross account struct606struct EthCrossAccount {607	address eth;608	uint256 sub;609}610611enum CollectionPermissions {612	CollectionAdmin,613	TokenOwner614}615616/// @dev anonymous struct617struct Tuple41 {618	CollectionPermissions field_0;619	bool field_1;620}621622/// @dev anonymous struct623struct Tuple38 {624	bool field_0;625	uint256[] field_1;626}627628/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.629enum CollectionLimits {630	/// @dev How many tokens can a user have on one account.631	AccountTokenOwnership,632	/// @dev How many bytes of data are available for sponsorship.633	SponsoredDataSize,634	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]635	SponsoredDataRateLimit,636	/// @dev How many tokens can be mined into this collection.637	TokenLimit,638	/// @dev Timeouts for transfer sponsoring.639	SponsorTransferTimeout,640	/// @dev Timeout for sponsoring an approval in passed blocks.641	SponsorApproveTimeout,642	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).643	OwnerCanTransfer,644	/// @dev Can the collection owner burn other people's tokens.645	OwnerCanDestroy,646	/// @dev Is it possible to send tokens from this collection between users.647	TransferEnabled648}649650/// @dev anonymous struct651struct Tuple32 {652	CollectionLimits field_0;653	bool field_1;654	uint256 field_2;655}656657/// @dev anonymous struct658struct Tuple29 {659	address field_0;660	uint256 field_1;661}662663/// @dev the ERC-165 identifier for this interface is 0x5b5e139f664contract ERC721Metadata is Dummy, ERC165 {665	// /// @notice A descriptive name for a collection of NFTs in this contract666	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`667	// /// @dev EVM selector for this function is: 0x06fdde03,668	// ///  or in textual repr: name()669	// function name() public view returns (string memory) {670	// 	require(false, stub_error);671	// 	dummy;672	// 	return "";673	// }674675	// /// @notice An abbreviated name for NFTs in this contract676	// /// @dev real implementation of this function lies in `ERC721UniqueExtensions`677	// /// @dev EVM selector for this function is: 0x95d89b41,678	// ///  or in textual repr: symbol()679	// function symbol() public view returns (string memory) {680	// 	require(false, stub_error);681	// 	dummy;682	// 	return "";683	// }684685	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.686	///687	/// @dev If the token has a `url` property and it is not empty, it is returned.688	///  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`.689	///  If the collection property `baseURI` is empty or absent, return "" (empty string)690	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix691	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).692	///693	/// @return token's const_metadata694	/// @dev EVM selector for this function is: 0xc87b56dd,695	///  or in textual repr: tokenURI(uint256)696	function tokenURI(uint256 tokenId) public view returns (string memory) {697		require(false, stub_error);698		tokenId;699		dummy;700		return "";701	}702}703704/// @title ERC721 Token that can be irreversibly burned (destroyed).705/// @dev the ERC-165 identifier for this interface is 0x42966c68706contract ERC721Burnable is Dummy, ERC165 {707	/// @notice Burns a specific ERC721 token.708	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized709	///  operator of the current owner.710	/// @param tokenId The RFT to approve711	/// @dev EVM selector for this function is: 0x42966c68,712	///  or in textual repr: burn(uint256)713	function burn(uint256 tokenId) public {714		require(false, stub_error);715		tokenId;716		dummy = 0;717	}718}719720/// @dev inlined interface721contract ERC721UniqueMintableEvents {722	event MintingFinished();723}724725/// @title ERC721 minting logic.726/// @dev the ERC-165 identifier for this interface is 0x476ff149727contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {728	/// @dev EVM selector for this function is: 0x05d2035b,729	///  or in textual repr: mintingFinished()730	function mintingFinished() public view returns (bool) {731		require(false, stub_error);732		dummy;733		return false;734	}735736	/// @notice Function to mint token.737	/// @param to The new owner738	/// @return uint256 The id of the newly minted token739	/// @dev EVM selector for this function is: 0x6a627842,740	///  or in textual repr: mint(address)741	function mint(address to) public returns (uint256) {742		require(false, stub_error);743		to;744		dummy = 0;745		return 0;746	}747748	// /// @notice Function to mint token.749	// /// @dev `tokenId` should be obtained with `nextTokenId` method,750	// ///  unlike standard, you can't specify it manually751	// /// @param to The new owner752	// /// @param tokenId ID of the minted RFT753	// /// @dev EVM selector for this function is: 0x40c10f19,754	// ///  or in textual repr: mint(address,uint256)755	// function mint(address to, uint256 tokenId) public returns (bool) {756	// 	require(false, stub_error);757	// 	to;758	// 	tokenId;759	// 	dummy = 0;760	// 	return false;761	// }762763	/// @notice Function to mint token with the given tokenUri.764	/// @param to The new owner765	/// @param tokenUri Token URI that would be stored in the NFT properties766	/// @return uint256 The id of the newly minted token767	/// @dev EVM selector for this function is: 0x45c17782,768	///  or in textual repr: mintWithTokenURI(address,string)769	function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {770		require(false, stub_error);771		to;772		tokenUri;773		dummy = 0;774		return 0;775	}776777	// /// @notice Function to mint token with the given tokenUri.778	// /// @dev `tokenId` should be obtained with `nextTokenId` method,779	// ///  unlike standard, you can't specify it manually780	// /// @param to The new owner781	// /// @param tokenId ID of the minted RFT782	// /// @param tokenUri Token URI that would be stored in the RFT properties783	// /// @dev EVM selector for this function is: 0x50bb4e7f,784	// ///  or in textual repr: mintWithTokenURI(address,uint256,string)785	// function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {786	// 	require(false, stub_error);787	// 	to;788	// 	tokenId;789	// 	tokenUri;790	// 	dummy = 0;791	// 	return false;792	// }793794	/// @dev Not implemented795	/// @dev EVM selector for this function is: 0x7d64bcb4,796	///  or in textual repr: finishMinting()797	function finishMinting() public returns (bool) {798		require(false, stub_error);799		dummy = 0;800		return false;801	}802}803804/// @title Unique extensions for ERC721.805/// @dev the ERC-165 identifier for this interface is 0x12f7d6c1806contract ERC721UniqueExtensions is Dummy, ERC165 {807	/// @notice A descriptive name for a collection of NFTs in this contract808	/// @dev EVM selector for this function is: 0x06fdde03,809	///  or in textual repr: name()810	function name() public view returns (string memory) {811		require(false, stub_error);812		dummy;813		return "";814	}815816	/// @notice An abbreviated name for NFTs in this contract817	/// @dev EVM selector for this function is: 0x95d89b41,818	///  or in textual repr: symbol()819	function symbol() public view returns (string memory) {820		require(false, stub_error);821		dummy;822		return "";823	}824825	/// @notice A description for the collection.826	/// @dev EVM selector for this function is: 0x7284e416,827	///  or in textual repr: description()828	function description() public view returns (string memory) {829		require(false, stub_error);830		dummy;831		return "";832	}833834	/// Returns the owner (in cross format) of the token.835	///836	/// @param tokenId Id for the token.837	/// @dev EVM selector for this function is: 0x2b29dace,838	///  or in textual repr: crossOwnerOf(uint256)839	function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {840		require(false, stub_error);841		tokenId;842		dummy;843		return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);844	}845846	/// Returns the token properties.847	///848	/// @param tokenId Id for the token.849	/// @param keys Properties keys. Empty keys for all propertyes.850	/// @return Vector of properties key/value pairs.851	/// @dev EVM selector for this function is: 0xe07ede7e,852	///  or in textual repr: properties(uint256,string[])853	function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {854		require(false, stub_error);855		tokenId;856		keys;857		dummy;858		return new Property[](0);859	}860861	/// @notice Transfer ownership of an RFT862	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`863	///  is the zero address. Throws if `tokenId` is not a valid RFT.864	///  Throws if RFT pieces have multiple owners.865	/// @param to The new owner866	/// @param tokenId The RFT to transfer867	/// @dev EVM selector for this function is: 0xa9059cbb,868	///  or in textual repr: transfer(address,uint256)869	function transfer(address to, uint256 tokenId) public {870		require(false, stub_error);871		to;872		tokenId;873		dummy = 0;874	}875876	/// @notice Transfer ownership of an RFT877	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`878	///  is the zero address. Throws if `tokenId` is not a valid RFT.879	///  Throws if RFT pieces have multiple owners.880	/// @param to The new owner881	/// @param tokenId The RFT 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 RFT892	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`893	///  is the zero address. Throws if `tokenId` is not a valid RFT.894	///  Throws if RFT pieces have multiple owners.895	/// @param to The new owner896	/// @param tokenId The RFT 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 RFT. Throws if `from` is not the current owner. Throws914	// ///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.915	// ///  Throws if RFT pieces have multiple owners.916	// /// @param from The current owner of the RFT917	// /// @param tokenId The RFT to transfer918	// /// @dev EVM selector for this function is: 0x79cc6790,919	// ///  or in textual repr: burnFrom(address,uint256)920	// function burnFrom(address from, uint256 tokenId) public {921	// 	require(false, stub_error);922	// 	from;923	// 	tokenId;924	// 	dummy = 0;925	// }926927	/// @notice Burns a specific ERC721 token.928	/// @dev Throws unless `msg.sender` is the current owner or an authorized929	///  operator for this RFT. Throws if `from` is not the current owner. Throws930	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.931	///  Throws if RFT pieces have multiple owners.932	/// @param from The current owner of the RFT933	/// @param tokenId The RFT to transfer934	/// @dev EVM selector for this function is: 0xbb2f5a58,935	///  or in textual repr: burnFromCross((address,uint256),uint256)936	function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {937		require(false, stub_error);938		from;939		tokenId;940		dummy = 0;941	}942943	/// @notice Returns next free RFT ID.944	/// @dev EVM selector for this function is: 0x75794a3c,945	///  or in textual repr: nextTokenId()946	function nextTokenId() public view returns (uint256) {947		require(false, stub_error);948		dummy;949		return 0;950	}951952	// /// @notice Function to mint multiple tokens.953	// /// @dev `tokenIds` should be an array of consecutive numbers and first number954	// ///  should be obtained with `nextTokenId` method955	// /// @param to The new owner956	// /// @param tokenIds IDs of the minted RFTs957	// /// @dev EVM selector for this function is: 0x44a9945e,958	// ///  or in textual repr: mintBulk(address,uint256[])959	// function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {960	// 	require(false, stub_error);961	// 	to;962	// 	tokenIds;963	// 	dummy = 0;964	// 	return false;965	// }966967	// /// @notice Function to mint multiple tokens with the given tokenUris.968	// /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive969	// ///  numbers and first number should be obtained with `nextTokenId` method970	// /// @param to The new owner971	// /// @param tokens array of pairs of token ID and token URI for minted tokens972	// /// @dev EVM selector for this function is: 0x36543006,973	// ///  or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])974	// function mintBulkWithTokenURI(address to, Tuple14[] memory tokens) public returns (bool) {975	// 	require(false, stub_error);976	// 	to;977	// 	tokens;978	// 	dummy = 0;979	// 	return false;980	// }981982	/// Returns EVM address for refungible token983	///984	/// @param token ID of the token985	/// @dev EVM selector for this function is: 0xab76fac6,986	///  or in textual repr: tokenContractAddress(uint256)987	function tokenContractAddress(uint256 token) public view returns (address) {988		require(false, stub_error);989		token;990		dummy;991		return 0x0000000000000000000000000000000000000000;992	}993}994995/// @dev anonymous struct996struct Tuple14 {997	uint256 field_0;998	string field_1;999}10001001/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1002/// @dev See https://eips.ethereum.org/EIPS/eip-7211003/// @dev the ERC-165 identifier for this interface is 0x780e9d631004contract ERC721Enumerable is Dummy, ERC165 {1005	/// @notice Enumerate valid RFTs1006	/// @param index A counter less than `totalSupply()`1007	/// @return The token identifier for the `index`th NFT,1008	///  (sort order not specified)1009	/// @dev EVM selector for this function is: 0x4f6ccce7,1010	///  or in textual repr: tokenByIndex(uint256)1011	function tokenByIndex(uint256 index) public view returns (uint256) {1012		require(false, stub_error);1013		index;1014		dummy;1015		return 0;1016	}10171018	/// Not implemented1019	/// @dev EVM selector for this function is: 0x2f745c59,1020	///  or in textual repr: tokenOfOwnerByIndex(address,uint256)1021	function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1022		require(false, stub_error);1023		owner;1024		index;1025		dummy;1026		return 0;1027	}10281029	/// @notice Count RFTs tracked by this contract1030	/// @return A count of valid RFTs tracked by this contract, where each one of1031	///  them has an assigned and queryable owner not equal to the zero address1032	/// @dev EVM selector for this function is: 0x18160ddd,1033	///  or in textual repr: totalSupply()1034	function totalSupply() public view returns (uint256) {1035		require(false, stub_error);1036		dummy;1037		return 0;1038	}1039}10401041/// @dev inlined interface1042contract ERC721Events {1043	event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1044	event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1045	event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1046}10471048/// @title ERC-721 Non-Fungible Token Standard1049/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1050/// @dev the ERC-165 identifier for this interface is 0x4016cd871051contract ERC721 is Dummy, ERC165, ERC721Events {1052	/// @notice Count all RFTs assigned to an owner1053	/// @dev RFTs assigned to the zero address are considered invalid, and this1054	///  function throws for queries about the zero address.1055	/// @param owner An address for whom to query the balance1056	/// @return The number of RFTs owned by `owner`, possibly zero1057	/// @dev EVM selector for this function is: 0x70a08231,1058	///  or in textual repr: balanceOf(address)1059	function balanceOf(address owner) public view returns (uint256) {1060		require(false, stub_error);1061		owner;1062		dummy;1063		return 0;1064	}10651066	/// @notice Find the owner of an RFT1067	/// @dev RFTs assigned to zero address are considered invalid, and queries1068	///  about them do throw.1069	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1070	///  the tokens that are partially owned.1071	/// @param tokenId The identifier for an RFT1072	/// @return The address of the owner of the RFT1073	/// @dev EVM selector for this function is: 0x6352211e,1074	///  or in textual repr: ownerOf(uint256)1075	function ownerOf(uint256 tokenId) public view returns (address) {1076		require(false, stub_error);1077		tokenId;1078		dummy;1079		return 0x0000000000000000000000000000000000000000;1080	}10811082	/// @dev Not implemented1083	/// @dev EVM selector for this function is: 0x60a11672,1084	///  or in textual repr: safeTransferFromWithData(address,address,uint256,bytes)1085	function safeTransferFromWithData(1086		address from,1087		address to,1088		uint256 tokenId,1089		bytes memory data1090	) public {1091		require(false, stub_error);1092		from;1093		to;1094		tokenId;1095		data;1096		dummy = 0;1097	}10981099	/// @dev Not implemented1100	/// @dev EVM selector for this function is: 0x42842e0e,1101	///  or in textual repr: safeTransferFrom(address,address,uint256)1102	function safeTransferFrom(1103		address from,1104		address to,1105		uint256 tokenId1106	) public {1107		require(false, stub_error);1108		from;1109		to;1110		tokenId;1111		dummy = 0;1112	}11131114	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1115	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1116	///  THEY MAY BE PERMANENTLY LOST1117	/// @dev Throws unless `msg.sender` is the current owner or an authorized1118	///  operator for this RFT. Throws if `from` is not the current owner. Throws1119	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1120	///  Throws if RFT pieces have multiple owners.1121	/// @param from The current owner of the NFT1122	/// @param to The new owner1123	/// @param tokenId The NFT to transfer1124	/// @dev EVM selector for this function is: 0x23b872dd,1125	///  or in textual repr: transferFrom(address,address,uint256)1126	function transferFrom(1127		address from,1128		address to,1129		uint256 tokenId1130	) public {1131		require(false, stub_error);1132		from;1133		to;1134		tokenId;1135		dummy = 0;1136	}11371138	/// @dev Not implemented1139	/// @dev EVM selector for this function is: 0x095ea7b3,1140	///  or in textual repr: approve(address,uint256)1141	function approve(address approved, uint256 tokenId) public {1142		require(false, stub_error);1143		approved;1144		tokenId;1145		dummy = 0;1146	}11471148	/// @notice Sets or unsets the approval of a given operator.1149	///  The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1150	/// @param operator Operator1151	/// @param approved Should operator status be granted or revoked?1152	/// @dev EVM selector for this function is: 0xa22cb465,1153	///  or in textual repr: setApprovalForAll(address,bool)1154	function setApprovalForAll(address operator, bool approved) public {1155		require(false, stub_error);1156		operator;1157		approved;1158		dummy = 0;1159	}11601161	/// @dev Not implemented1162	/// @dev EVM selector for this function is: 0x081812fc,1163	///  or in textual repr: getApproved(uint256)1164	function getApproved(uint256 tokenId) public view returns (address) {1165		require(false, stub_error);1166		tokenId;1167		dummy;1168		return 0x0000000000000000000000000000000000000000;1169	}11701171	/// @notice Tells whether the given `owner` approves the `operator`.1172	/// @dev EVM selector for this function is: 0xe985e9c5,1173	///  or in textual repr: isApprovedForAll(address,address)1174	function isApprovedForAll(address owner, address operator) public view returns (bool) {1175		require(false, stub_error);1176		owner;1177		operator;1178		dummy;1179		return false;1180	}11811182	/// @notice Returns collection helper contract address1183	/// @dev EVM selector for this function is: 0x1896cce6,1184	///  or in textual repr: collectionHelperAddress()1185	function collectionHelperAddress() public view returns (address) {1186		require(false, stub_error);1187		dummy;1188		return 0x0000000000000000000000000000000000000000;1189	}1190}11911192contract UniqueRefungible is1193	Dummy,1194	ERC165,1195	ERC721,1196	ERC721Enumerable,1197	ERC721UniqueExtensions,1198	ERC721UniqueMintable,1199	ERC721Burnable,1200	ERC721Metadata,1201	Collection,1202	TokenProperties1203{}

modifiedtests/src/eth/abi/fungible.jsondiff before after both

--- a/tests/src/eth/abi/fungible.json
+++ b/tests/src/eth/abi/fungible.json
@@ -208,6 +208,28 @@
   },
   {
     "inputs": [],
+    "name": "collectionLimits",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "enum CollectionLimits",
+            "name": "field_0",
+            "type": "uint8"
+          },
+          { "internalType": "bool", "name": "field_1", "type": "bool" },
+          { "internalType": "uint256", "name": "field_2", "type": "uint256" }
+        ],
+        "internalType": "struct Tuple20[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
     "name": "collectionNestingPermissions",
     "outputs": [
       {
@@ -219,7 +241,7 @@
           },
           { "internalType": "bool", "name": "field_1", "type": "bool" }
         ],
-        "internalType": "struct Tuple24[]",
+        "internalType": "struct Tuple29[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -240,7 +262,7 @@
             "type": "uint256[]"
           }
         ],
-        "internalType": "struct Tuple21",
+        "internalType": "struct Tuple26",
         "name": "",
         "type": "tuple"
       }
@@ -453,7 +475,12 @@
   },
   {
     "inputs": [
-      { "internalType": "string", "name": "limit", "type": "string" },
+      {
+        "internalType": "enum CollectionLimits",
+        "name": "limit",
+        "type": "uint8"
+      },
+      { "internalType": "bool", "name": "status", "type": "bool" },
       { "internalType": "uint256", "name": "value", "type": "uint256" }
     ],
     "name": "setCollectionLimit",

modifiedtests/src/eth/abi/nonFungible.jsondiff before after both

--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -238,6 +238,28 @@
   },
   {
     "inputs": [],
+    "name": "collectionLimits",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "enum CollectionLimits",
+            "name": "field_0",
+            "type": "uint8"
+          },
+          { "internalType": "bool", "name": "field_1", "type": "bool" },
+          { "internalType": "uint256", "name": "field_2", "type": "uint256" }
+        ],
+        "internalType": "struct Tuple33[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
     "name": "collectionNestingPermissions",
     "outputs": [
       {
@@ -249,7 +271,7 @@
           },
           { "internalType": "bool", "name": "field_1", "type": "bool" }
         ],
-        "internalType": "struct Tuple37[]",
+        "internalType": "struct Tuple42[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -270,7 +292,7 @@
             "type": "uint256[]"
           }
         ],
-        "internalType": "struct Tuple34",
+        "internalType": "struct Tuple39",
         "name": "",
         "type": "tuple"
       }
@@ -607,7 +629,12 @@
   },
   {
     "inputs": [
-      { "internalType": "string", "name": "limit", "type": "string" },
+      {
+        "internalType": "enum CollectionLimits",
+        "name": "limit",
+        "type": "uint8"
+      },
+      { "internalType": "bool", "name": "status", "type": "bool" },
       { "internalType": "uint256", "name": "value", "type": "uint256" }
     ],
     "name": "setCollectionLimit",
@@ -709,12 +736,12 @@
               },
               { "internalType": "bool", "name": "field_1", "type": "bool" }
             ],
-            "internalType": "struct Tuple46[]",
+            "internalType": "struct Tuple57[]",
             "name": "field_1",
             "type": "tuple[]"
           }
         ],
-        "internalType": "struct Tuple48[]",
+        "internalType": "struct Tuple59[]",
         "name": "permissions",
         "type": "tuple[]"
       }
@@ -775,12 +802,12 @@
               },
               { "internalType": "bool", "name": "field_1", "type": "bool" }
             ],
-            "internalType": "struct Tuple46[]",
+            "internalType": "struct Tuple57[]",
             "name": "field_1",
             "type": "tuple[]"
           }
         ],
-        "internalType": "struct Tuple48[]",
+        "internalType": "struct Tuple59[]",
         "name": "",
         "type": "tuple[]"
       }

modifiedtests/src/eth/abi/reFungible.jsondiff before after both

--- a/tests/src/eth/abi/reFungible.json
+++ b/tests/src/eth/abi/reFungible.json
@@ -220,6 +220,28 @@
   },
   {
     "inputs": [],
+    "name": "collectionLimits",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "enum CollectionLimits",
+            "name": "field_0",
+            "type": "uint8"
+          },
+          { "internalType": "bool", "name": "field_1", "type": "bool" },
+          { "internalType": "uint256", "name": "field_2", "type": "uint256" }
+        ],
+        "internalType": "struct Tuple32[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
     "name": "collectionNestingPermissions",
     "outputs": [
       {
@@ -231,7 +253,7 @@
           },
           { "internalType": "bool", "name": "field_1", "type": "bool" }
         ],
-        "internalType": "struct Tuple36[]",
+        "internalType": "struct Tuple41[]",
         "name": "",
         "type": "tuple[]"
       }
@@ -252,7 +274,7 @@
             "type": "uint256[]"
           }
         ],
-        "internalType": "struct Tuple33",
+        "internalType": "struct Tuple38",
         "name": "",
         "type": "tuple"
       }
@@ -589,7 +611,12 @@
   },
   {
     "inputs": [
-      { "internalType": "string", "name": "limit", "type": "string" },
+      {
+        "internalType": "enum CollectionLimits",
+        "name": "limit",
+        "type": "uint8"
+      },
+      { "internalType": "bool", "name": "status", "type": "bool" },
       { "internalType": "uint256", "name": "value", "type": "uint256" }
     ],
     "name": "setCollectionLimit",
@@ -691,12 +718,12 @@
               },
               { "internalType": "bool", "name": "field_1", "type": "bool" }
             ],
-            "internalType": "struct Tuple51[]",
+            "internalType": "struct Tuple56[]",
             "name": "field_1",
             "type": "tuple[]"
           }
         ],
-        "internalType": "struct Tuple53[]",
+        "internalType": "struct Tuple58[]",
         "name": "permissions",
         "type": "tuple[]"
       }
@@ -766,12 +793,12 @@
               },
               { "internalType": "bool", "name": "field_1", "type": "bool" }
             ],
-            "internalType": "struct Tuple51[]",
+            "internalType": "struct Tuple56[]",
             "name": "field_1",
             "type": "tuple[]"
           }
         ],
-        "internalType": "struct Tuple53[]",
+        "internalType": "struct Tuple58[]",
         "name": "",
         "type": "tuple[]"
       }

modifiedtests/src/eth/api/UniqueFungible.soldiff before after both

--- a/tests/src/eth/api/UniqueFungible.sol
+++ b/tests/src/eth/api/UniqueFungible.sol
@@ -13,7 +13,7 @@
 }
 
 /// @title A contract that allows you to work with collections.
-/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
+/// @dev the ERC-165 identifier for this interface is 0x81172a75
 interface Collection is Dummy, ERC165 {
 	// /// Set collection property.
 	// ///
@@ -104,6 +104,23 @@
 	///  or in textual repr: collectionSponsor()
 	function collectionSponsor() external view returns (Tuple8 memory);
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	/// @dev EVM selector for this function is: 0xf63bc572,
+	///  or in textual repr: collectionLimits()
+	function collectionLimits() external view returns (Tuple19[] memory);
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -116,10 +133,15 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
-	/// @dev EVM selector for this function is: 0x4ad890a8,
-	///  or in textual repr: setCollectionLimit(string,uint256)
-	function setCollectionLimit(string memory limit, uint256 value) external;
+	/// @dev EVM selector for this function is: 0x88150bd0,
+	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)
+	function setCollectionLimit(
+		CollectionLimits limit,
+		bool status,
+		uint256 value
+	) external;
 
 	/// Get contract address.
 	/// @dev EVM selector for this function is: 0xf6b4dfb4,
@@ -169,12 +191,12 @@
 	/// Returns nesting for a collection
 	/// @dev EVM selector for this function is: 0x22d25bfe,
 	///  or in textual repr: collectionNestingRestrictedCollectionIds()
-	function collectionNestingRestrictedCollectionIds() external view returns (Tuple20 memory);
+	function collectionNestingRestrictedCollectionIds() external view returns (Tuple24 memory);
 
 	/// Returns permissions for a collection
 	/// @dev EVM selector for this function is: 0x5b2eaf4b,
 	///  or in textual repr: collectionNestingPermissions()
-	function collectionNestingPermissions() external view returns (Tuple23[] memory);
+	function collectionNestingPermissions() external view returns (Tuple27[] memory);
 
 	/// Set the collection access method.
 	/// @param mode Access mode
@@ -289,7 +311,7 @@
 }
 
 /// @dev anonymous struct
-struct Tuple23 {
+struct Tuple27 {
 	CollectionPermissions field_0;
 	bool field_1;
 }
@@ -300,11 +322,40 @@
 }
 
 /// @dev anonymous struct
-struct Tuple20 {
+struct Tuple24 {
 	bool field_0;
 	uint256[] field_1;
 }
 
+/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+enum CollectionLimits {
+	/// @dev How many tokens can a user have on one account.
+	AccountTokenOwnership,
+	/// @dev How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// @dev How many tokens can be mined into this collection.
+	TokenLimit,
+	/// @dev Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// @dev Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// @dev Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// @dev Is it possible to send tokens from this collection between users.
+	TransferEnabled
+}
+
+/// @dev anonymous struct
+struct Tuple19 {
+	CollectionLimits field_0;
+	bool field_1;
+	uint256 field_2;
+}
+
 /// @dev Property struct
 struct Property {
 	string key;

modifiedtests/src/eth/api/UniqueNFT.soldiff before after both

--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -30,11 +30,12 @@
 	/// @param permissions Permissions for keys.
 	/// @dev EVM selector for this function is: 0xbd92983a,
 	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
-	function setTokenPropertyPermissions(Tuple43[] memory permissions) external;
+	function setTokenPropertyPermissions(Tuple52[] memory permissions) external;
 
+	/// @notice Get permissions for token properties.
 	/// @dev EVM selector for this function is: 0xf23d7790,
 	///  or in textual repr: tokenPropertyPermissions()
-	function tokenPropertyPermissions() external view returns (Tuple43[] memory);
+	function tokenPropertyPermissions() external view returns (Tuple52[] memory);
 
 	// /// @notice Set token property value.
 	// /// @dev Throws error if `msg.sender` has no permission to edit the property.
@@ -85,26 +86,30 @@
 	bytes value;
 }
 
+/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.
 enum EthTokenPermissions {
+	/// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]
 	Mutable,
+	/// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]
 	TokenOwner,
+	/// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]
 	CollectionAdmin
 }
 
 /// @dev anonymous struct
-struct Tuple43 {
+struct Tuple52 {
 	string field_0;
-	Tuple41[] field_1;
+	Tuple50[] field_1;
 }
 
 /// @dev anonymous struct
-struct Tuple41 {
+struct Tuple50 {
 	EthTokenPermissions field_0;
 	bool field_1;
 }
 
 /// @title A contract that allows you to work with collections.
-/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
+/// @dev the ERC-165 identifier for this interface is 0x81172a75
 interface Collection is Dummy, ERC165 {
 	// /// Set collection property.
 	// ///
@@ -195,6 +200,23 @@
 	///  or in textual repr: collectionSponsor()
 	function collectionSponsor() external view returns (Tuple27 memory);
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	/// @dev EVM selector for this function is: 0xf63bc572,
+	///  or in textual repr: collectionLimits()
+	function collectionLimits() external view returns (Tuple30[] memory);
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -207,10 +229,15 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
-	/// @dev EVM selector for this function is: 0x4ad890a8,
-	///  or in textual repr: setCollectionLimit(string,uint256)
-	function setCollectionLimit(string memory limit, uint256 value) external;
+	/// @dev EVM selector for this function is: 0x88150bd0,
+	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)
+	function setCollectionLimit(
+		CollectionLimits limit,
+		bool status,
+		uint256 value
+	) external;
 
 	/// Get contract address.
 	/// @dev EVM selector for this function is: 0xf6b4dfb4,
@@ -260,12 +287,12 @@
 	/// Returns nesting for a collection
 	/// @dev EVM selector for this function is: 0x22d25bfe,
 	///  or in textual repr: collectionNestingRestrictedCollectionIds()
-	function collectionNestingRestrictedCollectionIds() external view returns (Tuple31 memory);
+	function collectionNestingRestrictedCollectionIds() external view returns (Tuple35 memory);
 
 	/// Returns permissions for a collection
 	/// @dev EVM selector for this function is: 0x5b2eaf4b,
 	///  or in textual repr: collectionNestingPermissions()
-	function collectionNestingPermissions() external view returns (Tuple34[] memory);
+	function collectionNestingPermissions() external view returns (Tuple38[] memory);
 
 	/// Set the collection access method.
 	/// @param mode Access mode
@@ -380,7 +407,7 @@
 }
 
 /// @dev anonymous struct
-struct Tuple34 {
+struct Tuple38 {
 	CollectionPermissions field_0;
 	bool field_1;
 }
@@ -391,11 +418,40 @@
 }
 
 /// @dev anonymous struct
-struct Tuple31 {
+struct Tuple35 {
 	bool field_0;
 	uint256[] field_1;
 }
 
+/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+enum CollectionLimits {
+	/// @dev How many tokens can a user have on one account.
+	AccountTokenOwnership,
+	/// @dev How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// @dev How many tokens can be mined into this collection.
+	TokenLimit,
+	/// @dev Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// @dev Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// @dev Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// @dev Is it possible to send tokens from this collection between users.
+	TransferEnabled
+}
+
+/// @dev anonymous struct
+struct Tuple30 {
+	CollectionLimits field_0;
+	bool field_1;
+	uint256 field_2;
+}
+
 /// @dev anonymous struct
 struct Tuple27 {
 	address field_0;

modifiedtests/src/eth/api/UniqueRefungible.soldiff before after both

--- a/tests/src/eth/api/UniqueRefungible.sol
+++ b/tests/src/eth/api/UniqueRefungible.sol
@@ -30,12 +30,12 @@
 	/// @param permissions Permissions for keys.
 	/// @dev EVM selector for this function is: 0xbd92983a,
 	///  or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
-	function setTokenPropertyPermissions(Tuple47[] memory permissions) external;
+	function setTokenPropertyPermissions(Tuple51[] memory permissions) external;
 
 	/// @notice Get permissions for token properties.
 	/// @dev EVM selector for this function is: 0xf23d7790,
 	///  or in textual repr: tokenPropertyPermissions()
-	function tokenPropertyPermissions() external view returns (Tuple47[] memory);
+	function tokenPropertyPermissions() external view returns (Tuple51[] memory);
 
 	// /// @notice Set token property value.
 	// /// @dev Throws error if `msg.sender` has no permission to edit the property.
@@ -86,26 +86,30 @@
 	bytes value;
 }
 
+/// @dev Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.
 enum EthTokenPermissions {
+	/// @dev Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]
 	Mutable,
+	/// @dev Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]
 	TokenOwner,
+	/// @dev Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]
 	CollectionAdmin
 }
 
 /// @dev anonymous struct
-struct Tuple47 {
+struct Tuple51 {
 	string field_0;
-	Tuple45[] field_1;
+	Tuple49[] field_1;
 }
 
 /// @dev anonymous struct
-struct Tuple45 {
+struct Tuple49 {
 	EthTokenPermissions field_0;
 	bool field_1;
 }
 
 /// @title A contract that allows you to work with collections.
-/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
+/// @dev the ERC-165 identifier for this interface is 0x81172a75
 interface Collection is Dummy, ERC165 {
 	// /// Set collection property.
 	// ///
@@ -196,6 +200,23 @@
 	///  or in textual repr: collectionSponsor()
 	function collectionSponsor() external view returns (Tuple26 memory);
 
+	/// Get current collection limits.
+	///
+	/// @return Array of tuples (byte, bool, uint256) with limits and their values. Order of limits:
+	/// 	"accountTokenOwnershipLimit",
+	/// 	"sponsoredDataSize",
+	/// 	"sponsoredDataRateLimit",
+	/// 	"tokenLimit",
+	/// 	"sponsorTransferTimeout",
+	/// 	"sponsorApproveTimeout"
+	///  	"ownerCanTransfer",
+	/// 	"ownerCanDestroy",
+	/// 	"transfersEnabled"
+	/// Return `false` if a limit not set.
+	/// @dev EVM selector for this function is: 0xf63bc572,
+	///  or in textual repr: collectionLimits()
+	function collectionLimits() external view returns (Tuple29[] memory);
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:
@@ -208,10 +229,15 @@
 	///  	"ownerCanTransfer",
 	/// 	"ownerCanDestroy",
 	/// 	"transfersEnabled"
+	/// @param status enable\disable limit. Works only with `true`.
 	/// @param value Value of the limit.
-	/// @dev EVM selector for this function is: 0x4ad890a8,
-	///  or in textual repr: setCollectionLimit(string,uint256)
-	function setCollectionLimit(string memory limit, uint256 value) external;
+	/// @dev EVM selector for this function is: 0x88150bd0,
+	///  or in textual repr: setCollectionLimit(uint8,bool,uint256)
+	function setCollectionLimit(
+		CollectionLimits limit,
+		bool status,
+		uint256 value
+	) external;
 
 	/// Get contract address.
 	/// @dev EVM selector for this function is: 0xf6b4dfb4,
@@ -261,12 +287,12 @@
 	/// Returns nesting for a collection
 	/// @dev EVM selector for this function is: 0x22d25bfe,
 	///  or in textual repr: collectionNestingRestrictedCollectionIds()
-	function collectionNestingRestrictedCollectionIds() external view returns (Tuple30 memory);
+	function collectionNestingRestrictedCollectionIds() external view returns (Tuple34 memory);
 
 	/// Returns permissions for a collection
 	/// @dev EVM selector for this function is: 0x5b2eaf4b,
 	///  or in textual repr: collectionNestingPermissions()
-	function collectionNestingPermissions() external view returns (Tuple33[] memory);
+	function collectionNestingPermissions() external view returns (Tuple37[] memory);
 
 	/// Set the collection access method.
 	/// @param mode Access mode
@@ -381,7 +407,7 @@
 }
 
 /// @dev anonymous struct
-struct Tuple33 {
+struct Tuple37 {
 	CollectionPermissions field_0;
 	bool field_1;
 }
@@ -392,11 +418,40 @@
 }
 
 /// @dev anonymous struct
-struct Tuple30 {
+struct Tuple34 {
 	bool field_0;
 	uint256[] field_1;
 }
 
+/// @dev [`CollectionLimits`](up_data_structs::CollectionLimits) representation for EVM.
+enum CollectionLimits {
+	/// @dev How many tokens can a user have on one account.
+	AccountTokenOwnership,
+	/// @dev How many bytes of data are available for sponsorship.
+	SponsoredDataSize,
+	/// @dev In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]
+	SponsoredDataRateLimit,
+	/// @dev How many tokens can be mined into this collection.
+	TokenLimit,
+	/// @dev Timeouts for transfer sponsoring.
+	SponsorTransferTimeout,
+	/// @dev Timeout for sponsoring an approval in passed blocks.
+	SponsorApproveTimeout,
+	/// @dev Whether the collection owner of the collection can send tokens (which belong to other users).
+	OwnerCanTransfer,
+	/// @dev Can the collection owner burn other people's tokens.
+	OwnerCanDestroy,
+	/// @dev Is it possible to send tokens from this collection between users.
+	TransferEnabled
+}
+
+/// @dev anonymous struct
+struct Tuple29 {
+	CollectionLimits field_0;
+	bool field_1;
+	uint256 field_2;
+}
+
 /// @dev anonymous struct
 struct Tuple26 {
 	address field_0;

modifiedtests/src/eth/collectionLimits.test.tsdiff before after both

--- a/tests/src/eth/collectionLimits.test.ts
+++ b/tests/src/eth/collectionLimits.test.ts
@@ -1,6 +1,7 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {Pallets} from '../util';
 import {expect, itEth, usingEthPlaygrounds} from './util';
+import {CollectionLimits} from './util/playgrounds/types';
 
 
 describe('Can set collection limits', () => {
@@ -44,20 +45,33 @@
         transfersEnabled: false,
       };
      
-      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.case, owner);
-      await collection.methods.setCollectionLimit('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit).send();
-      await collection.methods.setCollectionLimit('sponsoredDataSize', limits.sponsoredDataSize).send();
-      await collection.methods.setCollectionLimit('sponsoredDataRateLimit', limits.sponsoredDataRateLimit).send();
-      await collection.methods.setCollectionLimit('tokenLimit', limits.tokenLimit).send();
-      await collection.methods.setCollectionLimit('sponsorTransferTimeout', limits.sponsorTransferTimeout).send();
-      await collection.methods.setCollectionLimit('sponsorApproveTimeout', limits.sponsorApproveTimeout).send();
-      await collection.methods.setCollectionLimit('ownerCanTransfer', limits.ownerCanTransfer).send();
-      await collection.methods.setCollectionLimit('ownerCanDestroy', limits.ownerCanDestroy).send();
-      await collection.methods.setCollectionLimit('transfersEnabled', limits.transfersEnabled).send();
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, testCase.case, owner);
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, limits.accountTokenOwnershipLimit).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.SponsoredDataSize, true, limits.sponsoredDataSize).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.SponsoredDataRateLimit, true, limits.sponsoredDataRateLimit).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.TokenLimit, true, limits.tokenLimit).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.SponsorTransferTimeout, true, limits.sponsorTransferTimeout).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.SponsorApproveTimeout, true, limits.sponsorApproveTimeout).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.OwnerCanTransfer, true, limits.ownerCanTransfer).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.OwnerCanDestroy, true, limits.ownerCanDestroy).send();
+      await collectionEvm.methods.setCollectionLimit(CollectionLimits.TransferEnabled, true, limits.transfersEnabled).send();
       
+      // Check limits from sub:
       const data = (await helper.rft.getData(collectionId))!;
       expect(data.raw.limits).to.deep.eq(expectedLimits);
       expect(await helper.collection.getEffectiveLimits(collectionId)).to.deep.eq(expectedLimits);
+      // Check limits from eth:
+      const limitsEvm = await collectionEvm.methods.collectionLimits().call({from: owner});
+      expect(limitsEvm).to.have.length(9);
+      expect(limitsEvm[0]).to.deep.eq([CollectionLimits.AccountTokenOwnership.toString(), true, limits.accountTokenOwnershipLimit.toString()]);
+      expect(limitsEvm[1]).to.deep.eq([CollectionLimits.SponsoredDataSize.toString(), true, limits.sponsoredDataSize.toString()]);
+      expect(limitsEvm[2]).to.deep.eq([CollectionLimits.SponsoredDataRateLimit.toString(), true, limits.sponsoredDataRateLimit.toString()]);
+      expect(limitsEvm[3]).to.deep.eq([CollectionLimits.TokenLimit.toString(), true, limits.tokenLimit.toString()]);
+      expect(limitsEvm[4]).to.deep.eq([CollectionLimits.SponsorTransferTimeout.toString(), true, limits.sponsorTransferTimeout.toString()]);
+      expect(limitsEvm[5]).to.deep.eq([CollectionLimits.SponsorApproveTimeout.toString(), true, limits.sponsorApproveTimeout.toString()]);
+      expect(limitsEvm[6]).to.deep.eq([CollectionLimits.OwnerCanTransfer.toString(), true, limits.ownerCanTransfer.toString()]);
+      expect(limitsEvm[7]).to.deep.eq([CollectionLimits.OwnerCanDestroy.toString(), true, limits.ownerCanDestroy.toString()]);
+      expect(limitsEvm[8]).to.deep.eq([CollectionLimits.TransferEnabled.toString(), true, limits.transfersEnabled.toString()]);
     }));
 });
 
@@ -84,17 +98,48 @@
       const owner = await helper.eth.createAccountWithBalance(donor);
       const {collectionAddress} = await helper.eth.createCollection(testCase.case, owner, 'Limits', 'absolutely anything', 'ISNI', 18);
       const collectionEvm = helper.ethNativeContract.collection(collectionAddress, testCase.case, owner);
+
+      // Cannot set non-existing limit
       await expect(collectionEvm.methods
-        .setCollectionLimit('badLimit', '1')
-        .call()).to.be.rejectedWith('unknown limit "badLimit"');
-      
+        .setCollectionLimit(9, true, 1)
+        .call()).to.be.rejectedWith('Returned error: VM Exception while processing transaction: revert Value not convertible into enum "CollectionLimits"');      
+        
+      // Cannot disable limits
+      await expect(collectionEvm.methods
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, false, 200)
+        .call()).to.be.rejectedWith('Returned error: VM Exception while processing transaction: revert user can\'t disable limits');
+
       await expect(collectionEvm.methods
-        .setCollectionLimit(Object.keys(invalidLimits)[0], invalidLimits.accountTokenOwnershipLimit)
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, invalidLimits.accountTokenOwnershipLimit)
         .call()).to.be.rejectedWith(`can't convert value to u32 "${invalidLimits.accountTokenOwnershipLimit}"`);
-      
+ 
       await expect(collectionEvm.methods
-        .setCollectionLimit(Object.keys(invalidLimits)[1], invalidLimits.transfersEnabled)
+        .setCollectionLimit(CollectionLimits.TransferEnabled, true, 3)
         .call()).to.be.rejectedWith(`can't convert value to boolean "${invalidLimits.transfersEnabled}"`);
+
+      expect(() => collectionEvm.methods
+        .setCollectionLimit(CollectionLimits.SponsoredDataSize, true, -1).send()).to.throw('value out-of-bounds');
     }));
+
+  [
+    {case: 'nft' as const, requiredPallets: []},
+    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+    {case: 'ft' as const, requiredPallets: []},
+  ].map(testCase =>
+    itEth.ifWithPallets(`Non-owner and non-admin cannot set collection limits for ${testCase.case}`, testCase.requiredPallets || [], async ({helper}) => {
+      const owner = await helper.eth.createAccountWithBalance(donor);
+      const nonOwner = await helper.eth.createAccountWithBalance(donor);
+      const {collectionAddress} = await helper.eth.createCollection(testCase.case, owner, 'Limits', 'absolutely anything', 'FLO', 18);
+
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, testCase.case, owner);
+      await expect(collectionEvm.methods
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
+        .call({from: nonOwner}))
+        .to.be.rejectedWith('NoPermission');
+
+      await expect(collectionEvm.methods
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
+        .send({from: nonOwner}))
+        .to.be.rejected;
+    }));
 });
-  
\ No newline at end of file

modifiedtests/src/eth/createFTCollection.test.tsdiff before after both

--- a/tests/src/eth/createFTCollection.test.ts
+++ b/tests/src/eth/createFTCollection.test.ts
@@ -18,6 +18,7 @@
 import {evmToAddress} from '@polkadot/util-crypto';
 import {Pallets, requirePalletsOrSkip} from '../util';
 import {expect, itEth, usingEthPlaygrounds} from './util';
+import { CollectionLimits } from './util/playgrounds/types';
 
 const DECIMALS = 18;
 
@@ -196,7 +197,7 @@
     }
     {
       await expect(peasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });
@@ -221,7 +222,7 @@
     }
     {
       await expect(peasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });

modifiedtests/src/eth/createNFTCollection.test.tsdiff before after both

--- a/tests/src/eth/createNFTCollection.test.ts
+++ b/tests/src/eth/createNFTCollection.test.ts
@@ -17,6 +17,7 @@
 import {evmToAddress} from '@polkadot/util-crypto';
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect, itEth, usingEthPlaygrounds} from './util';
+import { CollectionLimits } from './util/playgrounds/types';
 
 
 describe('Create NFT collection from EVM', () => {
@@ -207,7 +208,7 @@
     }
     {
       await expect(malfeasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });
@@ -232,7 +233,7 @@
     }
     {
       await expect(malfeasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });

modifiedtests/src/eth/createRFTCollection.test.tsdiff before after both

--- a/tests/src/eth/createRFTCollection.test.ts
+++ b/tests/src/eth/createRFTCollection.test.ts
@@ -18,6 +18,7 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {Pallets, requirePalletsOrSkip} from '../util';
 import {expect, itEth, usingEthPlaygrounds} from './util';
+import {CollectionLimits} from './util/playgrounds/types';
 
 
 describe('Create RFT collection from EVM', () => {
@@ -239,7 +240,7 @@
     }
     {
       await expect(peasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });
@@ -264,7 +265,7 @@
     }
     {
       await expect(peasantCollection.methods
-        .setCollectionLimit('accountTokenOwnershipLimit', '1000')
+        .setCollectionLimit(CollectionLimits.AccountTokenOwnership, true, 1000)
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
   });

modifiedtests/src/eth/events.test.tsdiff before after both

--- a/tests/src/eth/events.test.ts
+++ b/tests/src/eth/events.test.ts
@@ -19,7 +19,7 @@
 import {EthUniqueHelper, itEth, usingEthPlaygrounds} from './util';
 import {IEvent, TCollectionMode} from '../util/playgrounds/types';
 import {Pallets, requirePalletsOrSkip} from '../util';
-import {EthTokenPermissions, NormalizedEvent} from './util/playgrounds/types';
+import {CollectionLimits, EthTokenPermissions, NormalizedEvent} from './util/playgrounds/types';
 
 let donor: IKeyringPair;
   
@@ -234,7 +234,7 @@
   });
   const {unsubscribe, collectedEvents: subEvents} = await helper.subscribeEvents([{section: 'common', names: ['CollectionLimitSet']}]);
   {
-    await collection.methods.setCollectionLimit('ownerCanTransfer', 0n).send({from: owner});
+    await collection.methods.setCollectionLimit(CollectionLimits.OwnerCanTransfer, true, 0).send({from: owner});
     await helper.wait.newBlocks(1);
     expect(ethEvents).to.be.like([
       {

modifiedtests/src/eth/util/playgrounds/types.tsdiff before after both

--- a/tests/src/eth/util/playgrounds/types.ts
+++ b/tests/src/eth/util/playgrounds/types.ts
@@ -24,4 +24,15 @@
   Mutable,
   TokenOwner,
   CollectionAdmin
-}
\ No newline at end of file
+}
+export enum CollectionLimits {
+  AccountTokenOwnership,
+	SponsoredDataSize,
+	SponsoredDataRateLimit,
+	TokenLimit,
+	SponsorTransferTimeout,
+	SponsorApproveTimeout,
+	OwnerCanTransfer,
+	OwnerCanDestroy,
+	TransferEnabled
+}

modifiedtests/src/pallet-presence.test.tsdiff before after both

--- a/tests/src/pallet-presence.test.ts
+++ b/tests/src/pallet-presence.test.ts
@@ -84,6 +84,7 @@
         );
       } else if (chain.eq('UNIQUE')) {
         // Insert Unique additional pallets here
+        requiredPallets.push(foreignAssets);
       }
     });
   });