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

25use pallet_evm_coder_substrate::dispatch_to_evm;25use pallet_evm_coder_substrate::dispatch_to_evm;
26use sp_std::vec::Vec;26use sp_std::vec::Vec;
27use up_data_structs::{27use up_data_structs::{
28	Property, SponsoringRateLimit, OwnerRestrictedSet, AccessMode, CollectionPermissions,28	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
29	SponsoringRateLimit,
29};30};
30use alloc::format;31use alloc::format;
3132
409		save(self)410		save(self)
410	}411	}
412
413	/// Check that account is the owner or admin of the collection
414	///
415	/// @param user account to verify
416	/// @return "true" if account is the owner or admin
417	fn verify_owner_or_admin(&self, user: address) -> Result<bool> {
418		Ok(check_is_owner_or_admin(user, self)
419			.map(|_| true)
420			.unwrap_or(false))
421	}
422
423	/// Returns collection type
424	///
425	/// @return `Fungible` or `NFT` or `ReFungible`
426	fn unique_collection_type(&mut self) -> Result<string> {
427		let mode = match self.collection.mode {
428			CollectionMode::Fungible(_) => "Fungible",
429			CollectionMode::NFT => "NFT",
430			CollectionMode::ReFungible => "ReFungible",
431		};
432		Ok(mode.into())
433	}
411}434}
412435
413fn check_is_owner_or_admin<T: Config>(436fn check_is_owner_or_admin<T: Config>(
463			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)486			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)
464		}487		}
488
489		/// Key "parentNft".
490		pub fn parent_nft() -> up_data_structs::PropertyKey {
491			property_key_from_bytes(b"parentNft").expect(EXPECT_CONVERT_ERROR)
492		}
465	}493	}
466494
467	/// Values.495	/// Values.

1112		collection: &CollectionHandle<T>,1112		collection: &CollectionHandle<T>,
1113		sender: &T::CrossAccountId,1113		sender: &T::CrossAccountId,
1114		property_permission: PropertyKeyPermission,1114		property_permission: PropertyKeyPermission,
1115	) -> DispatchResult {1115	) -> DispatchResult {
1116		Self::set_scoped_property_permission(
1117			collection,
1118			sender,
1119			PropertyScope::None,
1120			property_permission,
1121		)
1122	}
1123
1124	/// Set collection property permission with scope.
1125	///
1126	/// * `collection` - Collection handler.
1127	/// * `sender` - The owner or administrator of the collection.
1128	/// * `scope` - Property scope.
1129	/// * `property_permission` - Property permission.
1130	pub fn set_scoped_property_permission(
1131		collection: &CollectionHandle<T>,
1132		sender: &T::CrossAccountId,
1133		scope: PropertyScope,
1134		property_permission: PropertyKeyPermission,
1135	) -> DispatchResult {
1116		collection.check_is_owner_or_admin(sender)?;1136		collection.check_is_owner_or_admin(sender)?;
11171137
1118		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);1138		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);
11261146
1127		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {1147		CollectionPropertyPermissions::<T>::try_mutate(collection.id, |permissions| {
1128			let property_permission = property_permission.clone();1148			let property_permission = property_permission.clone();
1129			permissions.try_set(property_permission.key, property_permission.permission)1149			permissions.try_scoped_set(
1150				scope,
1151				property_permission.key,
1152				property_permission.permission,
1153			)
1130		})1154		})
1131		.map_err(<Error<T>>::from)?;1155		.map_err(<Error<T>>::from)?;
1148		collection: &CollectionHandle<T>,1172		collection: &CollectionHandle<T>,
1149		sender: &T::CrossAccountId,1173		sender: &T::CrossAccountId,
1150		property_permissions: Vec<PropertyKeyPermission>,1174		property_permissions: Vec<PropertyKeyPermission>,
1151	) -> DispatchResult {1175	) -> DispatchResult {
1176		Self::set_scoped_token_property_permissions(
1177			collection,
1178			sender,
1179			PropertyScope::None,
1180			property_permissions,
1181		)
1182	}
1183
1184	/// Set token property permission with scope.
1185	///
1186	/// * `collection` - Collection handler.
1187	/// * `sender` - The owner or administrator of the collection.
1188	/// * `scope` - Property scope.
1189	/// * `property_permissions` - Property permissions.
1190	#[transactional]
1191	pub fn set_scoped_token_property_permissions(
1192		collection: &CollectionHandle<T>,
1193		sender: &T::CrossAccountId,
1194		scope: PropertyScope,
1195		property_permissions: Vec<PropertyKeyPermission>,
1196	) -> DispatchResult {
1152		for prop_pemission in property_permissions {1197		for prop_pemission in property_permissions {
1153			Self::set_property_permission(collection, sender, prop_pemission)?;1198			Self::set_scoped_property_permission(collection, sender, scope, prop_pemission)?;
1154		}1199		}
11551200
1156		Ok(())1201		Ok(())
1431			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))1476			.saturating_add(Self::burn_recursively_breadth_raw(max_breadth))
1432	}1477	}
1478
1479	/// The price of retrieving token owner
1480	fn token_owner() -> Weight;
1433}1481}
14341482
1435/// Weight info extension trait for refungible pallet.1483/// Weight info extension trait for refungible pallet.
1568	///1616	///
1569	/// * `sender` - Must be either the owner of the token or its admin.1617	/// * `sender` - Must be either the owner of the token or its admin.
1570	/// * `token_id` - The token for which the properties are being set.1618	/// * `token_id` - The token for which the properties are being set.
1571	/// * `properties` - Properties to be set.1619	/// * `property_permissions` - Property permissions to be set.
1572	/// * `budget` - Budget for setting properties.1620	/// * `budget` - Budget for setting properties.
1573	fn set_token_property_permissions(1621	fn set_token_property_permissions(
1574		&self,1622		&self,

104		0104		0
105	}105	}
106
107	fn token_owner() -> Weight {
108		0
109	}
106}110}
107111
108/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete112/// Implementation of `CommonCollectionOperations` for `FungibleHandle`. It wraps FungibleHandle Pallete

binary blob — no preview

31	);31	);
32}32}
33
34// Selector: 6cf113cd
35contract Collection is Dummy, ERC165 {
36	// Set collection property.
37	//
38	// @param key Property key.
39	// @param value Propery value.
40	//
41	// Selector: setCollectionProperty(string,bytes) 2f073f66
42	function setCollectionProperty(string memory key, bytes memory value)
43		public
44	{
45		require(false, stub_error);
46		key;
47		value;
48		dummy = 0;
49	}
50
51	// Delete collection property.
52	//
53	// @param key Property key.
54	//
55	// Selector: deleteCollectionProperty(string) 7b7debce
56	function deleteCollectionProperty(string memory key) public {
57		require(false, stub_error);
58		key;
59		dummy = 0;
60	}
61
62	// Get collection property.
63	//
64	// @dev Throws error if key not found.
65	//
66	// @param key Property key.
67	// @return bytes The property corresponding to the key.
68	//
69	// Selector: collectionProperty(string) cf24fd6d
70	function collectionProperty(string memory key)
71		public
72		view
73		returns (bytes memory)
74	{
75		require(false, stub_error);
76		key;
77		dummy;
78		return hex"";
79	}
80
81	// Set the sponsor of the collection.
82	//
83	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
84	//
85	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
86	//
87	// Selector: setCollectionSponsor(address) 7623402e
88	function setCollectionSponsor(address sponsor) public {
89		require(false, stub_error);
90		sponsor;
91		dummy = 0;
92	}
93
94	// Collection sponsorship confirmation.
95	//
96	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
97	//
98	// Selector: confirmCollectionSponsorship() 3c50e97a
99	function confirmCollectionSponsorship() public {
100		require(false, stub_error);
101		dummy = 0;
102	}
103
104	// Set limits for the collection.
105	// @dev Throws error if limit not found.
106	// @param limit Name of the limit. Valid names:
107	// 	"accountTokenOwnershipLimit",
108	// 	"sponsoredDataSize",
109	// 	"sponsoredDataRateLimit",
110	// 	"tokenLimit",
111	// 	"sponsorTransferTimeout",
112	// 	"sponsorApproveTimeout"
113	// @param value Value of the limit.
114	//
115	// Selector: setCollectionLimit(string,uint32) 6a3841db
116	function setCollectionLimit(string memory limit, uint32 value) public {
117		require(false, stub_error);
118		limit;
119		value;
120		dummy = 0;
121	}
122
123	// Set limits for the collection.
124	// @dev Throws error if limit not found.
125	// @param limit Name of the limit. Valid names:
126	// 	"ownerCanTransfer",
127	// 	"ownerCanDestroy",
128	// 	"transfersEnabled"
129	// @param value Value of the limit.
130	//
131	// Selector: setCollectionLimit(string,bool) 993b7fba
132	function setCollectionLimit(string memory limit, bool value) public {
133		require(false, stub_error);
134		limit;
135		value;
136		dummy = 0;
137	}
138
139	// Get contract address.
140	//
141	// Selector: contractAddress() f6b4dfb4
142	function contractAddress() public view returns (address) {
143		require(false, stub_error);
144		dummy;
145		return 0x0000000000000000000000000000000000000000;
146	}
147
148	// Add collection admin by substrate address.
149	// @param new_admin Substrate administrator address.
150	//
151	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
152	function addCollectionAdminSubstrate(uint256 newAdmin) public {
153		require(false, stub_error);
154		newAdmin;
155		dummy = 0;
156	}
157
158	// Remove collection admin by substrate address.
159	// @param admin Substrate administrator address.
160	//
161	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
162	function removeCollectionAdminSubstrate(uint256 admin) public {
163		require(false, stub_error);
164		admin;
165		dummy = 0;
166	}
167
168	// Add collection admin.
169	// @param new_admin Address of the added administrator.
170	//
171	// Selector: addCollectionAdmin(address) 92e462c7
172	function addCollectionAdmin(address newAdmin) public {
173		require(false, stub_error);
174		newAdmin;
175		dummy = 0;
176	}
177
178	// Remove collection admin.
179	//
180	// @param new_admin Address of the removed administrator.
181	//
182	// Selector: removeCollectionAdmin(address) fafd7b42
183	function removeCollectionAdmin(address admin) public {
184		require(false, stub_error);
185		admin;
186		dummy = 0;
187	}
188
189	// Toggle accessibility of collection nesting.
190	//
191	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
192	//
193	// Selector: setCollectionNesting(bool) 112d4586
194	function setCollectionNesting(bool enable) public {
195		require(false, stub_error);
196		enable;
197		dummy = 0;
198	}
199
200	// Toggle accessibility of collection nesting.
201	//
202	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
203	// @param collections Addresses of collections that will be available for nesting.
204	//
205	// Selector: setCollectionNesting(bool,address[]) 64872396
206	function setCollectionNesting(bool enable, address[] memory collections)
207		public
208	{
209		require(false, stub_error);
210		enable;
211		collections;
212		dummy = 0;
213	}
214
215	// Set the collection access method.
216	// @param mode Access mode
217	// 	0 for Normal
218	// 	1 for AllowList
219	//
220	// Selector: setCollectionAccess(uint8) 41835d4c
221	function setCollectionAccess(uint8 mode) public {
222		require(false, stub_error);
223		mode;
224		dummy = 0;
225	}
226
227	// Add the user to the allowed list.
228	//
229	// @param user Address of a trusted user.
230	//
231	// Selector: addToCollectionAllowList(address) 67844fe6
232	function addToCollectionAllowList(address user) public {
233		require(false, stub_error);
234		user;
235		dummy = 0;
236	}
237
238	// Remove the user from the allowed list.
239	//
240	// @param user Address of a removed user.
241	//
242	// Selector: removeFromCollectionAllowList(address) 85c51acb
243	function removeFromCollectionAllowList(address user) public {
244		require(false, stub_error);
245		user;
246		dummy = 0;
247	}
248
249	// Switch permission for minting.
250	//
251	// @param mode Enable if "true".
252	//
253	// Selector: setCollectionMintMode(bool) 00018e84
254	function setCollectionMintMode(bool mode) public {
255		require(false, stub_error);
256		mode;
257		dummy = 0;
258	}
259
260	// Check that account is the owner or admin of the collection
261	//
262	// @param user account to verify
263	// @return "true" if account is the owner or admin
264	//
265	// Selector: verifyOwnerOrAdmin(address) c2282493
266	function verifyOwnerOrAdmin(address user) public view returns (bool) {
267		require(false, stub_error);
268		user;
269		dummy;
270		return false;
271	}
272
273	// Returns collection type
274	//
275	// @return `Fungible` or `NFT` or `ReFungible`
276	//
277	// Selector: uniqueCollectionType() d34b55b8
278	function uniqueCollectionType() public returns (string memory) {
279		require(false, stub_error);
280		dummy = 0;
281		return "";
282	}
283}
33284
34// Selector: 79cc6790285// Selector: 79cc6790
35contract ERC20UniqueExtensions is Dummy, ERC165 {286contract ERC20UniqueExtensions is Dummy, ERC165 {
43	}294	}
44}295}
45
46// Selector: 7d9262e6
47contract Collection is Dummy, ERC165 {
48	// Set collection property.
49	//
50	// @param key Property key.
51	// @param value Propery value.
52	//
53	// Selector: setCollectionProperty(string,bytes) 2f073f66
54	function setCollectionProperty(string memory key, bytes memory value)
55		public
56	{
57		require(false, stub_error);
58		key;
59		value;
60		dummy = 0;
61	}
62
63	// Delete collection property.
64	//
65	// @param key Property key.
66	//
67	// Selector: deleteCollectionProperty(string) 7b7debce
68	function deleteCollectionProperty(string memory key) public {
69		require(false, stub_error);
70		key;
71		dummy = 0;
72	}
73
74	// Get collection property.
75	//
76	// @dev Throws error if key not found.
77	//
78	// @param key Property key.
79	// @return bytes The property corresponding to the key.
80	//
81	// Selector: collectionProperty(string) cf24fd6d
82	function collectionProperty(string memory key)
83		public
84		view
85		returns (bytes memory)
86	{
87		require(false, stub_error);
88		key;
89		dummy;
90		return hex"";
91	}
92
93	// Set the sponsor of the collection.
94	//
95	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
96	//
97	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
98	//
99	// Selector: setCollectionSponsor(address) 7623402e
100	function setCollectionSponsor(address sponsor) public {
101		require(false, stub_error);
102		sponsor;
103		dummy = 0;
104	}
105
106	// Collection sponsorship confirmation.
107	//
108	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
109	//
110	// Selector: confirmCollectionSponsorship() 3c50e97a
111	function confirmCollectionSponsorship() public {
112		require(false, stub_error);
113		dummy = 0;
114	}
115
116	// Set limits for the collection.
117	// @dev Throws error if limit not found.
118	// @param limit Name of the limit. Valid names:
119	// 	"accountTokenOwnershipLimit",
120	// 	"sponsoredDataSize",
121	// 	"sponsoredDataRateLimit",
122	// 	"tokenLimit",
123	// 	"sponsorTransferTimeout",
124	// 	"sponsorApproveTimeout"
125	// @param value Value of the limit.
126	//
127	// Selector: setCollectionLimit(string,uint32) 6a3841db
128	function setCollectionLimit(string memory limit, uint32 value) public {
129		require(false, stub_error);
130		limit;
131		value;
132		dummy = 0;
133	}
134
135	// Set limits for the collection.
136	// @dev Throws error if limit not found.
137	// @param limit Name of the limit. Valid names:
138	// 	"ownerCanTransfer",
139	// 	"ownerCanDestroy",
140	// 	"transfersEnabled"
141	// @param value Value of the limit.
142	//
143	// Selector: setCollectionLimit(string,bool) 993b7fba
144	function setCollectionLimit(string memory limit, bool value) public {
145		require(false, stub_error);
146		limit;
147		value;
148		dummy = 0;
149	}
150
151	// Get contract address.
152	//
153	// Selector: contractAddress() f6b4dfb4
154	function contractAddress() public view returns (address) {
155		require(false, stub_error);
156		dummy;
157		return 0x0000000000000000000000000000000000000000;
158	}
159
160	// Add collection admin by substrate address.
161	// @param new_admin Substrate administrator address.
162	//
163	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
164	function addCollectionAdminSubstrate(uint256 newAdmin) public {
165		require(false, stub_error);
166		newAdmin;
167		dummy = 0;
168	}
169
170	// Remove collection admin by substrate address.
171	// @param admin Substrate administrator address.
172	//
173	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
174	function removeCollectionAdminSubstrate(uint256 admin) public {
175		require(false, stub_error);
176		admin;
177		dummy = 0;
178	}
179
180	// Add collection admin.
181	// @param new_admin Address of the added administrator.
182	//
183	// Selector: addCollectionAdmin(address) 92e462c7
184	function addCollectionAdmin(address newAdmin) public {
185		require(false, stub_error);
186		newAdmin;
187		dummy = 0;
188	}
189
190	// Remove collection admin.
191	//
192	// @param new_admin Address of the removed administrator.
193	//
194	// Selector: removeCollectionAdmin(address) fafd7b42
195	function removeCollectionAdmin(address admin) public {
196		require(false, stub_error);
197		admin;
198		dummy = 0;
199	}
200
201	// Toggle accessibility of collection nesting.
202	//
203	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
204	//
205	// Selector: setCollectionNesting(bool) 112d4586
206	function setCollectionNesting(bool enable) public {
207		require(false, stub_error);
208		enable;
209		dummy = 0;
210	}
211
212	// Toggle accessibility of collection nesting.
213	//
214	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
215	// @param collections Addresses of collections that will be available for nesting.
216	//
217	// Selector: setCollectionNesting(bool,address[]) 64872396
218	function setCollectionNesting(bool enable, address[] memory collections)
219		public
220	{
221		require(false, stub_error);
222		enable;
223		collections;
224		dummy = 0;
225	}
226
227	// Set the collection access method.
228	// @param mode Access mode
229	// 	0 for Normal
230	// 	1 for AllowList
231	//
232	// Selector: setCollectionAccess(uint8) 41835d4c
233	function setCollectionAccess(uint8 mode) public {
234		require(false, stub_error);
235		mode;
236		dummy = 0;
237	}
238
239	// Add the user to the allowed list.
240	//
241	// @param user Address of a trusted user.
242	//
243	// Selector: addToCollectionAllowList(address) 67844fe6
244	function addToCollectionAllowList(address user) public {
245		require(false, stub_error);
246		user;
247		dummy = 0;
248	}
249
250	// Remove the user from the allowed list.
251	//
252	// @param user Address of a removed user.
253	//
254	// Selector: removeFromCollectionAllowList(address) 85c51acb
255	function removeFromCollectionAllowList(address user) public {
256		require(false, stub_error);
257		user;
258		dummy = 0;
259	}
260
261	// Switch permission for minting.
262	//
263	// @param mode Enable if "true".
264	//
265	// Selector: setCollectionMintMode(bool) 00018e84
266	function setCollectionMintMode(bool mode) public {
267		require(false, stub_error);
268		mode;
269		dummy = 0;
270	}
271}
272296
273// Selector: 942e8b22297// Selector: 942e8b22
274contract ERC20 is Dummy, ERC165, ERC20Events {298contract ERC20 is Dummy, ERC165, ERC20Events {

17use super::*;17use super::*;
18use crate::{Pallet, Config, NonfungibleHandle};18use crate::{Pallet, Config, NonfungibleHandle};
1919
20use sp_std::prelude::*;20use frame_benchmarking::{benchmarks, account};
21use pallet_common::benchmarking::{create_collection_raw, property_key, property_value};21use pallet_common::{
22	bench_init,
23	benchmarking::{create_collection_raw, property_key, property_value},
24	CommonCollectionOperations,
25};
22use frame_benchmarking::{benchmarks, account};26use sp_std::prelude::*;
23use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited};27use up_data_structs::{CollectionMode, MAX_ITEMS_PER_BATCH, MAX_PROPERTIES_PER_ITEM, budget::Unlimited};
24use pallet_common::bench_init;
2528
26const SEED: u32 = 1;29const SEED: u32 = 1;
2730
209		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();212		let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
210	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}213	}: {<Pallet<T>>::delete_token_properties(&collection, &owner, item, to_delete.into_iter(), &Unlimited)?}
214
215	token_owner {
216		bench_init!{
217			owner: sub; collection: collection(owner);
218			owner: cross_from_sub;
219		};
220		let item = create_max_item(&collection, &owner, owner.clone())?;
221
222	}: {collection.token_owner(item)}
211}223}
212224

119			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))119			.saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))
120	}120	}
121
122	fn token_owner() -> Weight {
123		<SelfWeightOf<T>>::token_owner()
124	}
121}125}
122126
123fn map_create_data<T: Config>(127fn map_create_data<T: Config>(

784		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)784		<PalletCommon<T>>::set_token_property_permissions(collection, sender, property_permissions)
785	}785	}
786
787	/// Set property permissions for the token with scope.
788	///
789	/// Sender should be the owner or admin of token's collection.
790	pub fn set_scoped_token_property_permissions(
791		collection: &CollectionHandle<T>,
792		sender: &T::CrossAccountId,
793		scope: PropertyScope,
794		property_permissions: Vec<PropertyKeyPermission>,
795	) -> DispatchResult {
796		<PalletCommon<T>>::set_scoped_token_property_permissions(
797			collection,
798			sender,
799			scope,
800			property_permissions,
801		)
802	}
786803
787	/// Set property permissions for the collection.804	/// Set property permissions for the collection.
788	///805	///

binary blob — no preview

373	}373	}
374}374}
375
376// Selector: 6cf113cd
377contract Collection is Dummy, ERC165 {
378	// Set collection property.
379	//
380	// @param key Property key.
381	// @param value Propery value.
382	//
383	// Selector: setCollectionProperty(string,bytes) 2f073f66
384	function setCollectionProperty(string memory key, bytes memory value)
385		public
386	{
387		require(false, stub_error);
388		key;
389		value;
390		dummy = 0;
391	}
392
393	// Delete collection property.
394	//
395	// @param key Property key.
396	//
397	// Selector: deleteCollectionProperty(string) 7b7debce
398	function deleteCollectionProperty(string memory key) public {
399		require(false, stub_error);
400		key;
401		dummy = 0;
402	}
403
404	// Get collection property.
405	//
406	// @dev Throws error if key not found.
407	//
408	// @param key Property key.
409	// @return bytes The property corresponding to the key.
410	//
411	// Selector: collectionProperty(string) cf24fd6d
412	function collectionProperty(string memory key)
413		public
414		view
415		returns (bytes memory)
416	{
417		require(false, stub_error);
418		key;
419		dummy;
420		return hex"";
421	}
422
423	// Set the sponsor of the collection.
424	//
425	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
426	//
427	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
428	//
429	// Selector: setCollectionSponsor(address) 7623402e
430	function setCollectionSponsor(address sponsor) public {
431		require(false, stub_error);
432		sponsor;
433		dummy = 0;
434	}
435
436	// Collection sponsorship confirmation.
437	//
438	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
439	//
440	// Selector: confirmCollectionSponsorship() 3c50e97a
441	function confirmCollectionSponsorship() public {
442		require(false, stub_error);
443		dummy = 0;
444	}
445
446	// Set limits for the collection.
447	// @dev Throws error if limit not found.
448	// @param limit Name of the limit. Valid names:
449	// 	"accountTokenOwnershipLimit",
450	// 	"sponsoredDataSize",
451	// 	"sponsoredDataRateLimit",
452	// 	"tokenLimit",
453	// 	"sponsorTransferTimeout",
454	// 	"sponsorApproveTimeout"
455	// @param value Value of the limit.
456	//
457	// Selector: setCollectionLimit(string,uint32) 6a3841db
458	function setCollectionLimit(string memory limit, uint32 value) public {
459		require(false, stub_error);
460		limit;
461		value;
462		dummy = 0;
463	}
464
465	// Set limits for the collection.
466	// @dev Throws error if limit not found.
467	// @param limit Name of the limit. Valid names:
468	// 	"ownerCanTransfer",
469	// 	"ownerCanDestroy",
470	// 	"transfersEnabled"
471	// @param value Value of the limit.
472	//
473	// Selector: setCollectionLimit(string,bool) 993b7fba
474	function setCollectionLimit(string memory limit, bool value) public {
475		require(false, stub_error);
476		limit;
477		value;
478		dummy = 0;
479	}
480
481	// Get contract address.
482	//
483	// Selector: contractAddress() f6b4dfb4
484	function contractAddress() public view returns (address) {
485		require(false, stub_error);
486		dummy;
487		return 0x0000000000000000000000000000000000000000;
488	}
489
490	// Add collection admin by substrate address.
491	// @param new_admin Substrate administrator address.
492	//
493	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
494	function addCollectionAdminSubstrate(uint256 newAdmin) public {
495		require(false, stub_error);
496		newAdmin;
497		dummy = 0;
498	}
499
500	// Remove collection admin by substrate address.
501	// @param admin Substrate administrator address.
502	//
503	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
504	function removeCollectionAdminSubstrate(uint256 admin) public {
505		require(false, stub_error);
506		admin;
507		dummy = 0;
508	}
509
510	// Add collection admin.
511	// @param new_admin Address of the added administrator.
512	//
513	// Selector: addCollectionAdmin(address) 92e462c7
514	function addCollectionAdmin(address newAdmin) public {
515		require(false, stub_error);
516		newAdmin;
517		dummy = 0;
518	}
519
520	// Remove collection admin.
521	//
522	// @param new_admin Address of the removed administrator.
523	//
524	// Selector: removeCollectionAdmin(address) fafd7b42
525	function removeCollectionAdmin(address admin) public {
526		require(false, stub_error);
527		admin;
528		dummy = 0;
529	}
530
531	// Toggle accessibility of collection nesting.
532	//
533	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
534	//
535	// Selector: setCollectionNesting(bool) 112d4586
536	function setCollectionNesting(bool enable) public {
537		require(false, stub_error);
538		enable;
539		dummy = 0;
540	}
541
542	// Toggle accessibility of collection nesting.
543	//
544	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
545	// @param collections Addresses of collections that will be available for nesting.
546	//
547	// Selector: setCollectionNesting(bool,address[]) 64872396
548	function setCollectionNesting(bool enable, address[] memory collections)
549		public
550	{
551		require(false, stub_error);
552		enable;
553		collections;
554		dummy = 0;
555	}
556
557	// Set the collection access method.
558	// @param mode Access mode
559	// 	0 for Normal
560	// 	1 for AllowList
561	//
562	// Selector: setCollectionAccess(uint8) 41835d4c
563	function setCollectionAccess(uint8 mode) public {
564		require(false, stub_error);
565		mode;
566		dummy = 0;
567	}
568
569	// Add the user to the allowed list.
570	//
571	// @param user Address of a trusted user.
572	//
573	// Selector: addToCollectionAllowList(address) 67844fe6
574	function addToCollectionAllowList(address user) public {
575		require(false, stub_error);
576		user;
577		dummy = 0;
578	}
579
580	// Remove the user from the allowed list.
581	//
582	// @param user Address of a removed user.
583	//
584	// Selector: removeFromCollectionAllowList(address) 85c51acb
585	function removeFromCollectionAllowList(address user) public {
586		require(false, stub_error);
587		user;
588		dummy = 0;
589	}
590
591	// Switch permission for minting.
592	//
593	// @param mode Enable if "true".
594	//
595	// Selector: setCollectionMintMode(bool) 00018e84
596	function setCollectionMintMode(bool mode) public {
597		require(false, stub_error);
598		mode;
599		dummy = 0;
600	}
601
602	// Check that account is the owner or admin of the collection
603	//
604	// @param user account to verify
605	// @return "true" if account is the owner or admin
606	//
607	// Selector: verifyOwnerOrAdmin(address) c2282493
608	function verifyOwnerOrAdmin(address user) public view returns (bool) {
609		require(false, stub_error);
610		user;
611		dummy;
612		return false;
613	}
614
615	// Returns collection type
616	//
617	// @return `Fungible` or `NFT` or `ReFungible`
618	//
619	// Selector: uniqueCollectionType() d34b55b8
620	function uniqueCollectionType() public returns (string memory) {
621		require(false, stub_error);
622		dummy = 0;
623		return "";
624	}
625}
375626
376// Selector: 780e9d63627// Selector: 780e9d63
377contract ERC721Enumerable is Dummy, ERC165 {628contract ERC721Enumerable is Dummy, ERC165 {
415	}666	}
416}667}
417
418// Selector: 7d9262e6
419contract Collection is Dummy, ERC165 {
420	// Set collection property.
421	//
422	// @param key Property key.
423	// @param value Propery value.
424	//
425	// Selector: setCollectionProperty(string,bytes) 2f073f66
426	function setCollectionProperty(string memory key, bytes memory value)
427		public
428	{
429		require(false, stub_error);
430		key;
431		value;
432		dummy = 0;
433	}
434
435	// Delete collection property.
436	//
437	// @param key Property key.
438	//
439	// Selector: deleteCollectionProperty(string) 7b7debce
440	function deleteCollectionProperty(string memory key) public {
441		require(false, stub_error);
442		key;
443		dummy = 0;
444	}
445
446	// Get collection property.
447	//
448	// @dev Throws error if key not found.
449	//
450	// @param key Property key.
451	// @return bytes The property corresponding to the key.
452	//
453	// Selector: collectionProperty(string) cf24fd6d
454	function collectionProperty(string memory key)
455		public
456		view
457		returns (bytes memory)
458	{
459		require(false, stub_error);
460		key;
461		dummy;
462		return hex"";
463	}
464
465	// Set the sponsor of the collection.
466	//
467	// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
468	//
469	// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.
470	//
471	// Selector: setCollectionSponsor(address) 7623402e
472	function setCollectionSponsor(address sponsor) public {
473		require(false, stub_error);
474		sponsor;
475		dummy = 0;
476	}
477
478	// Collection sponsorship confirmation.
479	//
480	// @dev After setting the sponsor for the collection, it must be confirmed with this function.
481	//
482	// Selector: confirmCollectionSponsorship() 3c50e97a
483	function confirmCollectionSponsorship() public {
484		require(false, stub_error);
485		dummy = 0;
486	}
487
488	// Set limits for the collection.
489	// @dev Throws error if limit not found.
490	// @param limit Name of the limit. Valid names:
491	// 	"accountTokenOwnershipLimit",
492	// 	"sponsoredDataSize",
493	// 	"sponsoredDataRateLimit",
494	// 	"tokenLimit",
495	// 	"sponsorTransferTimeout",
496	// 	"sponsorApproveTimeout"
497	// @param value Value of the limit.
498	//
499	// Selector: setCollectionLimit(string,uint32) 6a3841db
500	function setCollectionLimit(string memory limit, uint32 value) public {
501		require(false, stub_error);
502		limit;
503		value;
504		dummy = 0;
505	}
506
507	// Set limits for the collection.
508	// @dev Throws error if limit not found.
509	// @param limit Name of the limit. Valid names:
510	// 	"ownerCanTransfer",
511	// 	"ownerCanDestroy",
512	// 	"transfersEnabled"
513	// @param value Value of the limit.
514	//
515	// Selector: setCollectionLimit(string,bool) 993b7fba
516	function setCollectionLimit(string memory limit, bool value) public {
517		require(false, stub_error);
518		limit;
519		value;
520		dummy = 0;
521	}
522
523	// Get contract address.
524	//
525	// Selector: contractAddress() f6b4dfb4
526	function contractAddress() public view returns (address) {
527		require(false, stub_error);
528		dummy;
529		return 0x0000000000000000000000000000000000000000;
530	}
531
532	// Add collection admin by substrate address.
533	// @param new_admin Substrate administrator address.
534	//
535	// Selector: addCollectionAdminSubstrate(uint256) 5730062b
536	function addCollectionAdminSubstrate(uint256 newAdmin) public {
537		require(false, stub_error);
538		newAdmin;
539		dummy = 0;
540	}
541
542	// Remove collection admin by substrate address.
543	// @param admin Substrate administrator address.
544	//
545	// Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9
546	function removeCollectionAdminSubstrate(uint256 admin) public {
547		require(false, stub_error);
548		admin;
549		dummy = 0;
550	}
551
552	// Add collection admin.
553	// @param new_admin Address of the added administrator.
554	//
555	// Selector: addCollectionAdmin(address) 92e462c7
556	function addCollectionAdmin(address newAdmin) public {
557		require(false, stub_error);
558		newAdmin;
559		dummy = 0;
560	}
561
562	// Remove collection admin.
563	//
564	// @param new_admin Address of the removed administrator.
565	//
566	// Selector: removeCollectionAdmin(address) fafd7b42
567	function removeCollectionAdmin(address admin) public {
568		require(false, stub_error);
569		admin;
570		dummy = 0;
571	}
572
573	// Toggle accessibility of collection nesting.
574	//
575	// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'
576	//
577	// Selector: setCollectionNesting(bool) 112d4586
578	function setCollectionNesting(bool enable) public {
579		require(false, stub_error);
580		enable;
581		dummy = 0;
582	}
583
584	// Toggle accessibility of collection nesting.
585	//
586	// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'
587	// @param collections Addresses of collections that will be available for nesting.
588	//
589	// Selector: setCollectionNesting(bool,address[]) 64872396
590	function setCollectionNesting(bool enable, address[] memory collections)
591		public
592	{
593		require(false, stub_error);
594		enable;
595		collections;
596		dummy = 0;
597	}
598
599	// Set the collection access method.
600	// @param mode Access mode
601	// 	0 for Normal
602	// 	1 for AllowList
603	//
604	// Selector: setCollectionAccess(uint8) 41835d4c
605	function setCollectionAccess(uint8 mode) public {
606		require(false, stub_error);
607		mode;
608		dummy = 0;
609	}
610
611	// Add the user to the allowed list.
612	//
613	// @param user Address of a trusted user.
614	//
615	// Selector: addToCollectionAllowList(address) 67844fe6
616	function addToCollectionAllowList(address user) public {
617		require(false, stub_error);
618		user;
619		dummy = 0;
620	}
621
622	// Remove the user from the allowed list.
623	//
624	// @param user Address of a removed user.
625	//
626	// Selector: removeFromCollectionAllowList(address) 85c51acb
627	function removeFromCollectionAllowList(address user) public {
628		require(false, stub_error);
629		user;
630		dummy = 0;
631	}
632
633	// Switch permission for minting.
634	//
635	// @param mode Enable if "true".
636	//
637	// Selector: setCollectionMintMode(bool) 00018e84
638	function setCollectionMintMode(bool mode) public {
639		require(false, stub_error);
640		mode;
641		dummy = 0;
642	}
643}
644668
645// Selector: d74d154f669// Selector: d74d154f
646contract ERC721UniqueExtensions is Dummy, ERC165 {670contract ERC721UniqueExtensions is Dummy, ERC165 {