git.delta.rocks / unique-network / refs/commits / 3a0da55c0806

9999
100[[package]]100[[package]]
101name = "anyhow"101name = "anyhow"
102version = "1.0.58"102version = "1.0.57"
103source = "registry+https://github.com/rust-lang/crates.io-index"103source = "registry+https://github.com/rust-lang/crates.io-index"
104checksum = "bb07d2053ccdbe10e2af2995a2f116c1330396493dc1269f6a91d0ae82e19704"104checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"
105105
106[[package]]106[[package]]
107name = "approx"107name = "approx"
248248
249[[package]]249[[package]]
250name = "async-std"250name = "async-std"
251version = "1.12.0"251version = "1.11.0"
252source = "registry+https://github.com/rust-lang/crates.io-index"252source = "registry+https://github.com/rust-lang/crates.io-index"
253checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"253checksum = "52580991739c5cdb36cde8b2a516371c0a3b70dda36d916cc08b82372916808c"
254dependencies = [254dependencies = [
255 "async-attributes",255 "async-attributes",
256 "async-channel",256 "async-channel",
267 "kv-log-macro",267 "kv-log-macro",
268 "log",268 "log",
269 "memchr",269 "memchr",
270 "num_cpus",
270 "once_cell",271 "once_cell",
271 "pin-project-lite 0.2.9",272 "pin-project-lite 0.2.9",
272 "pin-utils",273 "pin-utils",
12991300
1300[[package]]1301[[package]]
1301name = "crossbeam-channel"1302name = "crossbeam-channel"
1302version = "0.5.5"1303version = "0.5.4"
1303source = "registry+https://github.com/rust-lang/crates.io-index"1304source = "registry+https://github.com/rust-lang/crates.io-index"
1304checksum = "4c02a4d71819009c192cf4872265391563fd6a84c81ff2c0f2a7026ca4c1d85c"1305checksum = "5aaa7bd5fb665c6864b5f963dd9097905c54125909c7aa94c9e18507cdbe6c53"
1305dependencies = [1306dependencies = [
1306 "cfg-if 1.0.0",1307 "cfg-if 1.0.0",
1307 "crossbeam-utils",1308 "crossbeam-utils",
13201321
1321[[package]]1322[[package]]
1322name = "crossbeam-epoch"1323name = "crossbeam-epoch"
1323version = "0.9.9"1324version = "0.9.8"
1324source = "registry+https://github.com/rust-lang/crates.io-index"1325source = "registry+https://github.com/rust-lang/crates.io-index"
1325checksum = "07db9d94cbd326813772c968ccd25999e5f8ae22f4f8d1b11effa37ef6ce281d"1326checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c"
1326dependencies = [1327dependencies = [
1327 "autocfg",1328 "autocfg",
1328 "cfg-if 1.0.0",1329 "cfg-if 1.0.0",
1329 "crossbeam-utils",1330 "crossbeam-utils",
1331 "lazy_static",
1330 "memoffset",1332 "memoffset",
1331 "once_cell",
1332 "scopeguard",1333 "scopeguard",
1333]1334]
13341335
13441345
1345[[package]]1346[[package]]
1346name = "crossbeam-utils"1347name = "crossbeam-utils"
1347version = "0.8.9"1348version = "0.8.8"
1348source = "registry+https://github.com/rust-lang/crates.io-index"1349source = "registry+https://github.com/rust-lang/crates.io-index"
1349checksum = "8ff1f980957787286a554052d03c7aee98d99cc32e09f6d45f0a814133c87978"1350checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38"
1350dependencies = [1351dependencies = [
1351 "cfg-if 1.0.0",1352 "cfg-if 1.0.0",
1352 "once_cell",1353 "lazy_static",
1353]1354]
13541355
1355[[package]]1356[[package]]
21572158
2158[[package]]2159[[package]]
2159name = "dyn-clone"2160name = "dyn-clone"
2160version = "1.0.6"2161version = "1.0.5"
2161source = "registry+https://github.com/rust-lang/crates.io-index"2162source = "registry+https://github.com/rust-lang/crates.io-index"
2162checksum = "140206b78fb2bc3edbcfc9b5ccbd0b30699cfe8d348b8b31b330e47df5291a5a"2163checksum = "21e50f3adc76d6a43f5ed73b698a87d0760ca74617f60f7c3b879003536fdd28"
21632164
2164[[package]]2165[[package]]
2165name = "ecdsa"2166name = "ecdsa"
36613662
3662[[package]]3663[[package]]
3663name = "indexmap"3664name = "indexmap"
3664version = "1.9.0"3665version = "1.8.2"
3665source = "registry+https://github.com/rust-lang/crates.io-index"3666source = "registry+https://github.com/rust-lang/crates.io-index"
3666checksum = "6c6392766afd7964e2531940894cffe4bd8d7d17dbc3c1c4857040fd4b33bdb3"3667checksum = "e6012d540c5baa3589337a98ce73408de9b5a25ec9fc2c6fd6be8f0d39e0ca5a"
3667dependencies = [3668dependencies = [
3668 "autocfg",3669 "autocfg",
3669 "hashbrown 0.12.1",3670 "hashbrown 0.11.2",
3670 "serde",3671 "serde",
3671]3672]
36723673
49554956
4956[[package]]4957[[package]]
4957name = "mio"4958name = "mio"
4958version = "0.8.4"4959version = "0.8.3"
4959source = "registry+https://github.com/rust-lang/crates.io-index"4960source = "registry+https://github.com/rust-lang/crates.io-index"
4960checksum = "57ee1c23c7c63b0c9250c339ffdc69255f110b298b901b9f6c82547b7b87caaf"4961checksum = "713d550d9b44d89174e066b7a6217ae06234c10cb47819a88290d2b353c31799"
4961dependencies = [4962dependencies = [
4962 "libc",4963 "libc",
4963 "log",4964 "log",
52085209
5209[[package]]5210[[package]]
5210name = "num-complex"5211name = "num-complex"
5211version = "0.4.2"5212version = "0.4.1"
5212source = "registry+https://github.com/rust-lang/crates.io-index"5213source = "registry+https://github.com/rust-lang/crates.io-index"
5213checksum = "7ae39348c8bc5fbd7f40c727a9925f03517afd2ab27d46702108b6a7e5414c19"5214checksum = "97fbc387afefefd5e9e39493299f3069e14a140dd34dc19b4c1c1a8fddb6a790"
5214dependencies = [5215dependencies = [
5215 "num-traits",5216 "num-traits",
5216]5217]
84358436
8436[[package]]8437[[package]]
8437name = "proc-macro2"8438name = "proc-macro2"
8438version = "1.0.40"8439version = "1.0.39"
8439source = "registry+https://github.com/rust-lang/crates.io-index"8440source = "registry+https://github.com/rust-lang/crates.io-index"
8440checksum = "dd96a1e8ed2596c337f8eae5f24924ec83f5ad5ab21ea8e455d3566c69fbcaf7"8441checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f"
8441dependencies = [8442dependencies = [
8442 "unicode-ident",8443 "unicode-ident",
8443]8444]
8557 "fp-evm-mapping",8558 "fp-evm-mapping",
8558 "fp-rpc",8559 "fp-rpc",
8559 "fp-self-contained",8560 "fp-self-contained",
8561 "frame-benchmarking",
8560 "frame-executive",8562 "frame-executive",
8561 "frame-support",8563 "frame-support",
8562 "frame-system",8564 "frame-system",
8565 "frame-system-benchmarking",
8563 "frame-system-rpc-runtime-api",8566 "frame-system-rpc-runtime-api",
8564 "frame-try-runtime",8567 "frame-try-runtime",
8568 "hex-literal",
8565 "log",8569 "log",
8566 "orml-vesting",8570 "orml-vesting",
8567 "pallet-aura",8571 "pallet-aura",
86398643
8640[[package]]8644[[package]]
8641name = "quote"8645name = "quote"
8642version = "1.0.20"8646version = "1.0.18"
8643source = "registry+https://github.com/rust-lang/crates.io-index"8647source = "registry+https://github.com/rust-lang/crates.io-index"
8644checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804"8648checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1"
8645dependencies = [8649dependencies = [
8646 "proc-macro2",8650 "proc-macro2",
8647]8651]
92649268
9265[[package]]9269[[package]]
9266name = "rustversion"9270name = "rustversion"
9267version = "1.0.7"9271version = "1.0.6"
9268source = "registry+https://github.com/rust-lang/crates.io-index"9272source = "registry+https://github.com/rust-lang/crates.io-index"
9269checksum = "a0a5f7c728f5d284929a1cccb5bc19884422bfe6ef4d6c409da2c41838983fcf"9273checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"
92709274
9271[[package]]9275[[package]]
9272name = "rw-stream-sink"9276name = "rw-stream-sink"
11587source = "registry+https://github.com/rust-lang/crates.io-index"11591source = "registry+https://github.com/rust-lang/crates.io-index"
11588checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"11592checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
11589dependencies = [11593dependencies = [
11590 "strum_macros 0.24.0",11594 "strum_macros 0.24.1",
11591]11595]
1159211596
11593[[package]]11597[[package]]
1160511609
11606[[package]]11610[[package]]
11607name = "strum_macros"11611name = "strum_macros"
11608version = "0.24.0"11612version = "0.24.1"
11609source = "registry+https://github.com/rust-lang/crates.io-index"11613source = "registry+https://github.com/rust-lang/crates.io-index"
11610checksum = "6878079b17446e4d3eba6192bb0a2950d5b14f0ed8424b852310e5a94345d0ef"11614checksum = "9550962e7cf70d9980392878dfaf1dcc3ece024f4cf3bf3c46b978d0bad61d6c"
11611dependencies = [11615dependencies = [
11612 "heck 0.4.0",11616 "heck 0.4.0",
11613 "proc-macro2",11617 "proc-macro2",
1176311767
11764[[package]]11768[[package]]
11765name = "syn"11769name = "syn"
11766version = "1.0.98"11770version = "1.0.96"
11767source = "registry+https://github.com/rust-lang/crates.io-index"11771source = "registry+https://github.com/rust-lang/crates.io-index"
11768checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd"11772checksum = "0748dd251e24453cb8717f0354206b91557e4ec8703673a4b30208f2abaf1ebf"
11769dependencies = [11773dependencies = [
11770 "proc-macro2",11774 "proc-macro2",
11771 "quote",11775 "quote",
1212212126
12123[[package]]12127[[package]]
12124name = "tower-service"12128name = "tower-service"
12125version = "0.3.2"12129version = "0.3.1"
12126source = "registry+https://github.com/rust-lang/crates.io-index"12130source = "registry+https://github.com/rust-lang/crates.io-index"
12127checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"12131checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
1212812132
12129[[package]]12133[[package]]
12130name = "tracing"12134name = "tracing"
12356source = "registry+https://github.com/rust-lang/crates.io-index"12360source = "registry+https://github.com/rust-lang/crates.io-index"
12357checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"12361checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
12358dependencies = [12362dependencies = [
12359 "cfg-if 1.0.0",12363 "cfg-if 0.1.10",
12360 "digest 0.10.3",12364 "digest 0.10.3",
12361 "rand 0.8.5",12365 "rand 0.8.5",
12362 "static_assertions",12366 "static_assertions",

5959
60.PHONY: _bench60.PHONY: _bench
61_bench:61_bench:
62	cargo run --release --features runtime-benchmarks,unique-runtime -- \62	cargo run --release --features runtime-benchmarks,$(RUNTIME) -- \
63	benchmark pallet --pallet pallet-$(if $(PALLET),$(PALLET),$(error Must set PALLET)) \63	benchmark pallet --pallet pallet-$(if $(PALLET),$(PALLET),$(error Must set PALLET)) \
64	--wasm-execution compiled --extrinsic '*' \64	--wasm-execution compiled --extrinsic '*' \
65	--template .maintain/frame-weight-template.hbs --steps=50 --repeat=80 --heap-pages=4096 \65	--template .maintain/frame-weight-template.hbs --steps=50 --repeat=80 --heap-pages=4096 \
101bench-rmrk-core:101bench-rmrk-core:
102	make _bench PALLET=proxy-rmrk-core102	make _bench PALLET=proxy-rmrk-core
103
104.PHONY: bench-rmrk-equip
105bench-rmrk-equip:
106	make _bench PALLET=proxy-rmrk-equip
103107
104.PHONY: bench108.PHONY: bench
105bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler bench-rmrk-core109bench: bench-evm-migration bench-unique bench-structure bench-fungible bench-refungible bench-nonfungible bench-scheduler bench-rmrk-core bench-rmrk-equip
106110

323[features]323[features]
324default = []324default = []
325runtime-benchmarks = [325runtime-benchmarks = [
326    'unique-runtime/runtime-benchmarks',326    'unique-runtime?/runtime-benchmarks',
327    'quartz-runtime?/runtime-benchmarks',
328    'opal-runtime/runtime-benchmarks',
327    'polkadot-service/runtime-benchmarks',329    'polkadot-service/runtime-benchmarks',
328]330]
329try-runtime = []331try-runtime = []

26use unique_runtime_common::types::*;26use unique_runtime_common::types::*;
2727
28#[cfg(feature = "unique-runtime")]28#[cfg(feature = "unique-runtime")]
29use unique_runtime as default_runtime;29pub use unique_runtime as default_runtime;
3030
31#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))]31#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))]
32use quartz_runtime as default_runtime;32pub use quartz_runtime as default_runtime;
3333
34#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))]34#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))]
35use opal_runtime as default_runtime;35pub use opal_runtime as default_runtime;
3636
37/// The `ChainSpec` parameterized for the unique runtime.37/// The `ChainSpec` parameterized for the unique runtime.
38#[cfg(feature = "unique-runtime")]38#[cfg(feature = "unique-runtime")]

3434
35use crate::{35use crate::{
36	chain_spec::{self, RuntimeId, RuntimeIdentification, ServiceId, ServiceIdentification},36	chain_spec::{
37		self, RuntimeId, RuntimeIdentification, ServiceId, ServiceIdentification, default_runtime,
38	},
37	cli::{Cli, RelayChainCli, Subcommand},39	cli::{Cli, RelayChainCli, Subcommand},
38	service::{new_partial, start_node, start_dev_node},40	service::{new_partial, start_node, start_dev_node},
44#[cfg(feature = "quartz-runtime")]46#[cfg(feature = "quartz-runtime")]
45use crate::service::QuartzRuntimeExecutor;47use crate::service::QuartzRuntimeExecutor;
4648
47use crate::service::OpalRuntimeExecutor;49use crate::service::{OpalRuntimeExecutor, DefaultRuntimeExecutor};
4850
49use codec::Encode;51use codec::Encode;
50use cumulus_primitives_core::ParaId;52use cumulus_primitives_core::ParaId;
372374
373			Ok(())375			Ok(())
374		}376		}
375		#[cfg(feature = "unique-runtime")]
376		Some(Subcommand::Benchmark(cmd)) => {377		Some(Subcommand::Benchmark(cmd)) => {
377			use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE};378			use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE};
378			let runner = cli.create_runner(cmd)?;379			let runner = cli.create_runner(cmd)?;
379			// Switch on the concrete benchmark sub-command-380			// Switch on the concrete benchmark sub-command-
380			match cmd {381			match cmd {
381				BenchmarkCmd::Pallet(cmd) => {382				BenchmarkCmd::Pallet(cmd) => {
382					if cfg!(feature = "runtime-benchmarks") {383					if cfg!(feature = "runtime-benchmarks") {
383						runner.sync_run(|config| cmd.run::<Block, UniqueRuntimeExecutor>(config))384						runner.sync_run(|config| cmd.run::<Block, DefaultRuntimeExecutor>(config))
384					} else {385					} else {
385						Err("Benchmarking wasn't enabled when building the node. \386						Err("Benchmarking wasn't enabled when building the node. \
386					You can enable it with `--features runtime-benchmarks`."387					You can enable it with `--features runtime-benchmarks`."
389				}390				}
390				BenchmarkCmd::Block(cmd) => runner.sync_run(|config| {391				BenchmarkCmd::Block(cmd) => runner.sync_run(|config| {
391					let partials = new_partial::<392					let partials = new_partial::<
392						unique_runtime::RuntimeApi,393						default_runtime::RuntimeApi,
393						UniqueRuntimeExecutor,394						DefaultRuntimeExecutor,
394						_,395						_,
395					>(&config, crate::service::parachain_build_import_queue)?;396					>(&config, crate::service::parachain_build_import_queue)?;
396					cmd.run(partials.client)397					cmd.run(partials.client)
397				}),398				}),
398				BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| {399				BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| {
399					let partials = new_partial::<400					let partials = new_partial::<
400						unique_runtime::RuntimeApi,401						default_runtime::RuntimeApi,
401						UniqueRuntimeExecutor,402						DefaultRuntimeExecutor,
402						_,403						_,
403					>(&config, crate::service::parachain_build_import_queue)?;404					>(&config, crate::service::parachain_build_import_queue)?;
404					let db = partials.backend.expose_db();405					let db = partials.backend.expose_db();
412				BenchmarkCmd::Overhead(_) => Err("Unsupported benchmarking command".into()),413				BenchmarkCmd::Overhead(_) => Err("Unsupported benchmarking command".into()),
413			}414			}
414		}415		}
415		#[cfg(not(feature = "unique-runtime"))]
416		Some(Subcommand::Benchmark(..)) => {
417			Err("benchmarking is only available with unique runtime enabled".into())
418		}
419		Some(Subcommand::TryRuntime(cmd)) => {416		Some(Subcommand::TryRuntime(cmd)) => {
420			if cfg!(feature = "try-runtime") {417			if cfg!(feature = "try-runtime") {
421				let runner = cli.create_runner(cmd)?;418				let runner = cli.create_runner(cmd)?;

83/// Opal native executor instance.82/// Opal native executor instance.
84pub struct OpalRuntimeExecutor;83pub struct OpalRuntimeExecutor;
84
85#[cfg(feature = "unique-runtime")]
86pub type DefaultRuntimeExecutor = UniqueRuntimeExecutor;
87
88#[cfg(all(not(feature = "unique-runtime"), feature = "quartz-runtime"))]
89pub type DefaultRuntimeExecutor = QuartzRuntimeExecutor;
90
91#[cfg(all(not(feature = "unique-runtime"), not(feature = "quartz-runtime")))]
92pub type DefaultRuntimeExecutor = OpalRuntimeExecutor;
8593
86#[cfg(feature = "unique-runtime")]94#[cfg(feature = "unique-runtime")]
87impl NativeExecutionDispatch for UniqueRuntimeExecutor {95impl NativeExecutionDispatch for UniqueRuntimeExecutor {

74	RmrkPropertyInfo,74	RmrkPropertyInfo,
75	RmrkBaseInfo,75	RmrkBaseInfo,
76	RmrkPartType,76	RmrkPartType,
77	RmrkTheme,77	RmrkBoundedTheme,
78	RmrkNftChild,78	RmrkNftChild,
79	CollectionPermissions,79	CollectionPermissions,
80	SchemaVersion,80	SchemaVersion,
543				RmrkPropertyInfo,543				RmrkPropertyInfo,
544				RmrkBaseInfo<T::AccountId>,544				RmrkBaseInfo<T::AccountId>,
545				RmrkPartType,545				RmrkPartType,
546				RmrkTheme,546				RmrkBoundedTheme,
547				RmrkNftChild,547				RmrkNftChild,
548			)>,548			)>,
549		),549		),

28use up_data_structs::{28use up_data_structs::{
29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,29	AccessMode, CollectionId, CustomDataLimit, TokenId, CreateCollectionData, CreateNftExData,
30	mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey,30	mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission, PropertyKey,
31	PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild,31	PropertyKeyPermission, Properties, PropertyScope, TrySetProperty, TokenChild, AuxPropertyValue,
32};32};
33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};33use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
34use pallet_common::{34use pallet_common::{
124		OnEmpty = up_data_structs::TokenProperties,124		OnEmpty = up_data_structs::TokenProperties,
125	>;125	>;
126
127	#[pallet::storage]
128	#[pallet::getter(fn token_aux_property)]
129	pub type TokenAuxProperties<T: Config> = StorageNMap<
130		Key = (
131			Key<Twox64Concat, CollectionId>,
132			Key<Twox64Concat, TokenId>,
133			Key<Twox64Concat, PropertyScope>,
134			Key<Twox64Concat, PropertyKey>,
135		),
136		Value = AuxPropertyValue,
137		QueryKind = OptionQuery,
138	>;
126139
127	/// Used to enumerate tokens owned by account140	/// Used to enumerate tokens owned by account
128	#[pallet::storage]141	#[pallet::storage]
294		Ok(())307		Ok(())
295	}308	}
309
310	pub fn try_mutate_token_aux_property<R, E>(
311		collection_id: CollectionId,
312		token_id: TokenId,
313		scope: PropertyScope,
314		key: PropertyKey,
315		f: impl FnOnce(&mut Option<AuxPropertyValue>) -> Result<R, E>,
316	) -> Result<R, E> {
317		<TokenAuxProperties<T>>::try_mutate((collection_id, token_id, scope, key), f)
318	}
319
320	pub fn remove_token_aux_property(
321		collection_id: CollectionId,
322		token_id: TokenId,
323		scope: PropertyScope,
324		key: PropertyKey,
325	) {
326		<TokenAuxProperties<T>>::remove((collection_id, token_id, scope, key));
327	}
328
329	pub fn iterate_token_aux_properties(
330		collection_id: CollectionId,
331		token_id: TokenId,
332		scope: PropertyScope,
333	) -> impl Iterator<Item = (PropertyKey, AuxPropertyValue)> {
334		<TokenAuxProperties<T>>::iter_prefix((collection_id, token_id, scope))
335	}
296336
297	pub fn current_token_id(collection_id: CollectionId) -> TokenId {337	pub fn current_token_id(collection_id: CollectionId) -> TokenId {
298		TokenId(<TokensMinted<T>>::get(collection_id))338		TokenId(<TokensMinted<T>>::get(collection_id))
375		<TokensBurnt<T>>::insert(collection.id, burnt);415		<TokensBurnt<T>>::insert(collection.id, burnt);
376		<TokenData<T>>::remove((collection.id, token));416		<TokenData<T>>::remove((collection.id, token));
377		<TokenProperties<T>>::remove((collection.id, token));417		<TokenProperties<T>>::remove((collection.id, token));
418		<TokenAuxProperties<T>>::remove_prefix((collection.id, token), None);
378		let old_spender = <Allowance<T>>::take((collection.id, token));419		let old_spender = <Allowance<T>>::take((collection.id, token));
379420
380		if let Some(old_spender) = old_spender {421		if let Some(old_spender) = old_spender {

8585
86	<Pallet<T>>::mint_nft(86	<Pallet<T>>::mint_nft(
87		RawOrigin::Signed(owner.clone()).into(),87		RawOrigin::Signed(owner.clone()).into(),
88		owner.clone(),88		None,
89		collection_id,89		collection_id,
90		royalty_recipient,90		royalty_recipient,
91		royalty_amount,91		royalty_amount,
108		}108		}
109	}109	}
110
111	fn current_nft_id(&self) -> RmrkNftId {
112		self.current_nft_id
113	}
114110
115	fn build<T: Config>(&mut self, owner: &T::AccountId) -> Result<RmrkNftId, DispatchError> {111	fn build<T: Config>(&mut self, owner: &T::AccountId) -> Result<RmrkNftId, DispatchError> {
116		create_nft::<T>(owner, self.collection_id)?;112		create_nft::<T>(owner, self.collection_id)?;
220		let b in 0..100;216		let b in 0..100;
221217
222		let caller: T::AccountId = account("caller", 0, SEED);218		let caller: T::AccountId = account("caller", 0, SEED);
223		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
224219
225		create_max_collection::<T>(&caller)?;220		create_max_collection::<T>(&caller)?;
226		let collection_id = 0;221		let collection_id = 0;
232		let transferable = true;227		let transferable = true;
233	}:  _(228	}:  _(
234		RawOrigin::Signed(caller),229		RawOrigin::Signed(caller),
235		owner,230		None,
236		collection_id,231		collection_id,
237		royalty_recipient,232		royalty_recipient,
238		royalty_amount,233		royalty_amount,
381376
382	add_basic_resource {377	add_basic_resource {
383		let caller: T::AccountId = account("caller", 0, SEED);378		let caller: T::AccountId = account("caller", 0, SEED);
384		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
385379
386		create_max_collection::<T>(&caller)?;380		create_max_collection::<T>(&caller)?;
387		let collection_id = 0;381		let collection_id = 0;
398392
399	add_composable_resource {393	add_composable_resource {
400		let caller: T::AccountId = account("caller", 0, SEED);394		let caller: T::AccountId = account("caller", 0, SEED);
401		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
402395
403		create_max_collection::<T>(&caller)?;396		create_max_collection::<T>(&caller)?;
404		let collection_id = 0;397		let collection_id = 0;
415408
416	add_slot_resource {409	add_slot_resource {
417		let caller: T::AccountId = account("caller", 0, SEED);410		let caller: T::AccountId = account("caller", 0, SEED);
418		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
419411
420		create_max_collection::<T>(&caller)?;412		create_max_collection::<T>(&caller)?;
421		let collection_id = 0;413		let collection_id = 0;
432424
433	remove_resource {425	remove_resource {
434		let caller: T::AccountId = account("caller", 0, SEED);426		let caller: T::AccountId = account("caller", 0, SEED);
435		<T as pallet_common::Config>::Currency::deposit_creating(&caller, T::CollectionCreationPrice::get());
436427
437		create_max_collection::<T>(&caller)?;428		create_max_collection::<T>(&caller)?;
438		let collection_id = 0;429		let collection_id = 0;
448			resource439			resource
449		)?;440		)?;
450441
451		let resource_id = 1;442		let resource_id = 0;
452	}: _(443	}: _(
453		RawOrigin::Signed(caller),444		RawOrigin::Signed(caller),
454		collection_id,445		collection_id,
460		let caller: T::AccountId = account("caller", 0, SEED);451		let caller: T::AccountId = account("caller", 0, SEED);
461		let admin: T::AccountId = account("admin", 0, SEED);452		let admin: T::AccountId = account("admin", 0, SEED);
462
463		<T as pallet_common::Config>::Currency::deposit_creating(&admin, T::CollectionCreationPrice::get());
464453
465		create_max_collection::<T>(&admin)?;454		create_max_collection::<T>(&admin)?;
466		let collection_id = 0;455		let collection_id = 0;
486			resource475			resource
487		)?;476		)?;
488477
489		let resource_id = 1;478		let resource_id = 0;
490	}: _(479	}: _(
491		RawOrigin::Signed(caller),480		RawOrigin::Signed(caller),
492		collection_id,481		collection_id,
498		let caller: T::AccountId = account("caller", 0, SEED);487		let caller: T::AccountId = account("caller", 0, SEED);
499		let admin: T::AccountId = account("admin", 0, SEED);488		let admin: T::AccountId = account("admin", 0, SEED);
500
501		<T as pallet_common::Config>::Currency::deposit_creating(&admin, T::CollectionCreationPrice::get());
502489
503		create_max_collection::<T>(&admin)?;490		create_max_collection::<T>(&admin)?;
504		let collection_id = 0;491		let collection_id = 0;
515			resource502			resource
516		)?;503		)?;
517504
518		let resource_id = 1;505		let resource_id = 0;
519506
520		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::AccountId(caller.clone());507		let new_owner = <RmrkAccountIdOrCollectionNftTuple<T::AccountId>>::AccountId(caller.clone());
521508

35pub mod benchmarking;35pub mod benchmarking;
36pub mod misc;36pub mod misc;
37pub mod property;37pub mod property;
38pub mod rpc;
38pub mod weights;39pub mod weights;
3940
40pub type SelfWeightOf<T> = <T as Config>::WeightInfo;41pub type SelfWeightOf<T> = <T as Config>::WeightInfo;
154		NftTypeEncodeError,155		NftTypeEncodeError,
155		RmrkPropertyKeyIsTooLong,156		RmrkPropertyKeyIsTooLong,
156		RmrkPropertyValueIsTooLong,157		RmrkPropertyValueIsTooLong,
158		RmrkPropertyIsNotFound,
157		UnableToDecodeRmrkData,159		UnableToDecodeRmrkData,
158160
159		/* RMRK compatible events */161		/* RMRK compatible events */
168		CannotSendToDescendentOrSelf,170		CannotSendToDescendentOrSelf,
169		CannotAcceptNonOwnedNft,171		CannotAcceptNonOwnedNft,
170		CannotRejectNonOwnedNft,172		CannotRejectNonOwnedNft,
173		CannotRejectNonPendingNft,
171		ResourceNotPending,174		ResourceNotPending,
175		NoAvailableResourceId,
172	}176	}
173177
174	#[pallet::call]178	#[pallet::call]
347		#[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]351		#[pallet::weight(<SelfWeightOf<T>>::mint_nft(resources.as_ref().map(|r| r.len() as u32).unwrap_or(0)))]
348		pub fn mint_nft(352		pub fn mint_nft(
349			origin: OriginFor<T>,353			origin: OriginFor<T>,
350			owner: T::AccountId,354			owner: Option<T::AccountId>,
351			collection_id: RmrkCollectionId,355			collection_id: RmrkCollectionId,
352			recipient: Option<T::AccountId>,356			recipient: Option<T::AccountId>,
353			royalty_amount: Option<Permill>,357			royalty_amount: Option<Permill>,
357		) -> DispatchResult {361		) -> DispatchResult {
358			let sender = ensure_signed(origin)?;362			let sender = ensure_signed(origin)?;
359			let cross_sender = T::CrossAccountId::from_sub(sender.clone());363			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
364
365			let owner = owner.unwrap_or(sender.clone());
360			let cross_owner = T::CrossAccountId::from_sub(owner.clone());366			let cross_owner = T::CrossAccountId::from_sub(owner.clone());
361367
362			let collection = Self::get_typed_nft_collection(368			let collection = Self::get_typed_nft_collection(
381					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,387					Self::rmrk_property(RoyaltyInfo, &royalty_info)?,
382					Self::rmrk_property(Metadata, &metadata)?,388					Self::rmrk_property(Metadata, &metadata)?,
383					Self::rmrk_property(Equipped, &false)?,389					Self::rmrk_property(Equipped, &false)?,
384					Self::rmrk_property(ResourceCollection, &None::<CollectionId>)?,
385					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,390					Self::rmrk_property(ResourcePriorities, &<Vec<u8>>::new())?,
391					Self::rmrk_property(NextResourceId, &(0 as RmrkResourceId))?,
386				]392				]
387				.into_iter(),393				.into_iter(),
388			)394			)
653			collection.check_is_external()?;659			collection.check_is_external()?;
654660
655			ensure!(661			ensure!(
662				<TokenData<T>>::get((collection_id, nft_id)).is_some(),
663				<Error<T>>::NoAvailableNftId
664			);
665
666			ensure!(
656				Self::get_nft_property_decoded(667				Self::get_nft_property_decoded(
657					collection_id,668					collection_id,
658					nft_id,669					nft_id,
659					RmrkProperty::PendingNftAccept670					RmrkProperty::PendingNftAccept
660				)?,671				)?,
661				<Error<T>>::NoPermission672				<Error<T>>::CannotRejectNonPendingNft
662			);673			);
663674
664			Self::destroy_nft(675			Self::destroy_nft(
686			origin: OriginFor<T>,697			origin: OriginFor<T>,
687			rmrk_collection_id: RmrkCollectionId,698			rmrk_collection_id: RmrkCollectionId,
688			rmrk_nft_id: RmrkNftId,699			rmrk_nft_id: RmrkNftId,
689			rmrk_resource_id: RmrkResourceId,700			resource_id: RmrkResourceId,
690		) -> DispatchResult {701		) -> DispatchResult {
691			let sender = ensure_signed(origin)?;702			let sender = ensure_signed(origin)?;
692			let cross_sender = T::CrossAccountId::from_sub(sender);703			let cross_sender = T::CrossAccountId::from_sub(sender);
698			collection.check_is_external()?;709			collection.check_is_external()?;
699710
700			let nft_id = rmrk_nft_id.into();711			let nft_id = rmrk_nft_id.into();
701			let resource_id = rmrk_resource_id.into();
702712
703			let budget = budget::Value::new(NESTING_BUDGET);713			let budget = budget::Value::new(NESTING_BUDGET);
704714
705			let nft_owner =715			let nft_owner =
706				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)716				<PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
707					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;717					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
708718
709			let resource_collection_id: Option<CollectionId> =719			Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {
710				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)720				ensure!(res.pending, <Error<T>>::ResourceNotPending);
711					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;721				ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
712722
713			let resource_collection_id =723				res.pending = false;
714				resource_collection_id.ok_or(<Error<T>>::ResourceDoesntExist)?;
715724
716			let is_pending: bool = Self::get_nft_property_decoded(725				Ok(())
717				resource_collection_id,
718				resource_id,
719				PendingResourceAccept,
720			)
721			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;726			})?;
722727
723			ensure!(is_pending, <Error<T>>::ResourceNotPending);
724
725			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
726
727			<PalletNft<T>>::set_scoped_token_property(
728				resource_collection_id,
729				rmrk_resource_id.into(),
730				PropertyScope::Rmrk,
731				Self::rmrk_property(PendingResourceAccept, &false)?,
732			)?;
733
734			Self::deposit_event(Event::<T>::ResourceAccepted {728			Self::deposit_event(Event::<T>::ResourceAccepted {
735				nft_id: rmrk_nft_id,729				nft_id: rmrk_nft_id,
736				resource_id: rmrk_resource_id,730				resource_id,
737			});731			});
738732
739			Ok(())733			Ok(())
746			origin: OriginFor<T>,740			origin: OriginFor<T>,
747			rmrk_collection_id: RmrkCollectionId,741			rmrk_collection_id: RmrkCollectionId,
748			rmrk_nft_id: RmrkNftId,742			rmrk_nft_id: RmrkNftId,
749			rmrk_resource_id: RmrkResourceId,743			resource_id: RmrkResourceId,
750		) -> DispatchResult {744		) -> DispatchResult {
751			let sender = ensure_signed(origin)?;745			let sender = ensure_signed(origin)?;
752			let cross_sender = T::CrossAccountId::from_sub(sender);746			let cross_sender = T::CrossAccountId::from_sub(sender);
758			collection.check_is_external()?;752			collection.check_is_external()?;
759753
760			let nft_id = rmrk_nft_id.into();754			let nft_id = rmrk_nft_id.into();
761			let resource_id = rmrk_resource_id.into();
762755
763			let budget = budget::Value::new(NESTING_BUDGET);756			let budget = budget::Value::new(NESTING_BUDGET);
764757
768761
769			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);762			ensure!(cross_sender == nft_owner, <Error<T>>::NoPermission);
770763
771			let resource_collection_id: Option<CollectionId> =764			let resource_id_key = Self::rmrk_property_key(ResourceId(resource_id))?;
772				Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)
773					.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
774765
775			let resource_collection_id =766			let resource_info = <PalletNft<T>>::token_aux_property((
776				resource_collection_id.ok_or(<Error<T>>::ResourceDoesntExist)?;767				collection_id,
768				nft_id,
769				PropertyScope::Rmrk,
770				resource_id_key.clone(),
771			))
772			.ok_or(<Error<T>>::ResourceDoesntExist)?;
777773
778			let is_pending: bool = Self::get_nft_property_decoded(774			let resource_info: RmrkResourceInfo = Self::decode_property(&resource_info)?;
779				resource_collection_id,
780				resource_id,
781				PendingResourceRemoval,
782			)
783			.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
784775
785			ensure!(is_pending, <Error<T>>::ResourceNotPending);776			ensure!(
777				resource_info.pending_removal,
778				<Error<T>>::ResourceNotPending
779			);
786780
787			let resource_collection = Self::get_typed_nft_collection(781			<PalletNft<T>>::remove_token_aux_property(
788				resource_collection_id,782				collection_id,
789				misc::CollectionType::Resource,783				nft_id,
784				PropertyScope::Rmrk,
785				resource_id_key,
790			)?;786			);
791787
792			let resource_data = <TokenData<T>>::get((resource_collection_id, resource_id))
793				.ok_or(<Error<T>>::ResourceDoesntExist)?;
794
795			let resource_owner = resource_data.owner;
796
797			<PalletNft<T>>::burn(
798				&resource_collection,
799				&resource_owner,
800				rmrk_resource_id.into(),
801			)
802			.map_err(Self::map_unique_err_to_proxy)?;
803
804			Self::deposit_event(Event::<T>::ResourceRemovalAccepted {788			Self::deposit_event(Event::<T>::ResourceRemovalAccepted {
805				nft_id: rmrk_nft_id,789				nft_id: rmrk_nft_id,
806				resource_id: rmrk_resource_id,790				resource_id,
807			});791			});
808792
809			Ok(())793			Ok(())
1014				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;998				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1015			collection.check_is_external()?;999			collection.check_is_external()?;
10161000
1017			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id.into())?;1001			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id)?;
10181002
1019			Self::deposit_event(Event::ResourceRemoval {1003			Self::deposit_event(Event::ResourceRemoval {
1020				nft_id,1004				nft_id,
1043	) -> Result<Property, DispatchError> {1027	) -> Result<Property, DispatchError> {
1044		let key = rmrk_key.to_key::<T>()?;1028		let key = rmrk_key.to_key::<T>()?;
10451029
1030		let value = Self::encode_property(value)?;
1031
1032		let property = Property { key, value };
1033
1034		Ok(property)
1035	}
1036
1037	pub fn encode_property<E: Encode, S: Get<u32>>(
1038		value: &E,
1039	) -> Result<BoundedBytes<S>, DispatchError> {
1046		let value = value1040		let value = value
1047			.encode()1041			.encode()
1048			.try_into()1042			.try_into()
1049			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;1043			.map_err(|_| <Error<T>>::RmrkPropertyValueIsTooLong)?;
10501044
1051		let property = Property { key, value };1045		Ok(value)
1052
1053		Ok(property)
1054	}1046	}
10551047
1056	pub fn decode_property<D: Decode>(vec: PropertyValue) -> Result<D, DispatchError> {1048	pub fn decode_property<D: Decode, S: Get<u32>>(
1049		vec: &BoundedBytes<S>,
1050	) -> Result<D, DispatchError> {
1057		vec.decode()1051		vec.decode()
1058			.map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())1052			.map_err(|_| <Error<T>>::UnableToDecodeRmrkData.into())
1059	}1053	}
1153		)1147		)
1154	}1148	}
11551149
1156	fn resource_add(1150	fn acquire_next_resource_id(
1157		sender: T::AccountId,
1158		collection_id: CollectionId,1151		collection_id: CollectionId,
1159		nft_id: TokenId,1152		nft_id: TokenId,
1160		resource: RmrkResourceTypes,
1161	) -> Result<RmrkResourceId, DispatchError> {1153	) -> Result<RmrkResourceId, DispatchError> {
1162		match resource {1154		let resource_id: RmrkResourceId =
1163			RmrkResourceTypes::Basic(resource) => Self::resource_add_helper(
1164				sender,1155			Self::get_nft_property_decoded(collection_id, nft_id, NextResourceId)?;
1165				collection_id,1156
1166				nft_id,
1167				[
1168					Self::rmrk_property(TokenType, &NftType::Resource)?,
1169					Self::rmrk_property(ResourceType, &misc::ResourceType::Basic)?,
1170					Self::rmrk_property(Src, &resource.src)?,
1171					Self::rmrk_property(Metadata, &resource.metadata)?,1157		let next_id = resource_id
1172					Self::rmrk_property(License, &resource.license)?,
1173					Self::rmrk_property(Thumb, &resource.thumb)?,
1174				]
1175				.into_iter(),
1176			),
1177			RmrkResourceTypes::Composable(resource) => Self::resource_add_helper(
1178				sender,1158			.checked_add(1)
1179				collection_id,
1180				nft_id.into(),
1181				[1159			.ok_or(<Error<T>>::NoAvailableResourceId)?;
1182					Self::rmrk_property(TokenType, &NftType::Resource)?,1160
1183					Self::rmrk_property(ResourceType, &misc::ResourceType::Composable)?,
1184					Self::rmrk_property(Parts, &resource.parts)?,
1185					Self::rmrk_property(Base, &resource.base)?,
1186					Self::rmrk_property(Src, &resource.src)?,
1187					Self::rmrk_property(Metadata, &resource.metadata)?,
1188					Self::rmrk_property(License, &resource.license)?,1161		<PalletNft<T>>::set_scoped_token_property(
1189					Self::rmrk_property(Thumb, &resource.thumb)?,
1190				]
1191				.into_iter(),
1192			),
1193			RmrkResourceTypes::Slot(resource) => Self::resource_add_helper(
1194				sender,1162			collection_id,
1195				collection_id,
1196				nft_id.into(),1163			nft_id,
1197				[1164			PropertyScope::Rmrk,
1198					Self::rmrk_property(TokenType, &NftType::Resource)?,
1199					Self::rmrk_property(ResourceType, &misc::ResourceType::Slot)?,1165			Self::rmrk_property(NextResourceId, &next_id)?,
1200					Self::rmrk_property(Base, &resource.base)?,1166		)?;
1201					Self::rmrk_property(Src, &resource.src)?,1167
1202					Self::rmrk_property(Metadata, &resource.metadata)?,1168		Ok(resource_id)
1203					Self::rmrk_property(Slot, &resource.slot)?,
1204					Self::rmrk_property(License, &resource.license)?,
1205					Self::rmrk_property(Thumb, &resource.thumb)?,
1206				]
1207				.into_iter(),
1208			),
1209		}
1210	}1169	}
12111170
1212	fn resource_add_helper(1171	fn resource_add(
1213		sender: T::AccountId,1172		sender: T::AccountId,
1214		collection_id: CollectionId,1173		collection_id: CollectionId,
1215		token_id: TokenId,1174		nft_id: TokenId,
1216		resource_properties: impl Iterator<Item = Property>,1175		resource: RmrkResourceTypes,
1217	) -> Result<RmrkResourceId, DispatchError> {1176	) -> Result<RmrkResourceId, DispatchError> {
1218		let collection =1177		let collection =
1219			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1178			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1222		let sender = T::CrossAccountId::from_sub(sender);1181		let sender = T::CrossAccountId::from_sub(sender);
1223		let budget = budget::Value::new(NESTING_BUDGET);1182		let budget = budget::Value::new(NESTING_BUDGET);
12241183
1225		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, token_id, &budget)1184		let nft_owner = <PalletStructure<T>>::find_topmost_owner(collection_id, nft_id, &budget)
1226			.map_err(Self::map_unique_err_to_proxy)?;1185			.map_err(Self::map_unique_err_to_proxy)?;
12271186
1228		let pending = sender != nft_owner;1187		let pending = sender != nft_owner;
12291188
1230		let resource_collection_id: Option<CollectionId> =1189		let id = Self::acquire_next_resource_id(collection_id, nft_id)?;
1231			Self::get_nft_property_decoded(collection_id, token_id, ResourceCollection)?;
12321190
1233		let resource_collection_id = match resource_collection_id {1191		let resource_info = RmrkResourceInfo {
1234			Some(id) => id,1192			id,
1235			None => {1193			resource,
1236				let resource_collection_id = Self::init_collection(
1237					sender.clone(),
1238					CreateCollectionData {1194			pending,
1239						..Default::default()
1240					},
1241					[Self::rmrk_property(1195			pending_removal: false,
1242						CollectionType,
1243						&misc::CollectionType::Resource,
1244					)?]
1245					.into_iter(),
1246				)?;
1247
1248				<PalletNft<T>>::set_scoped_token_property(
1249					collection_id,
1250					token_id,
1251					PropertyScope::Rmrk,
1252					Self::rmrk_property(ResourceCollection, &Some(resource_collection_id))?,
1253				)?;
1254
1255				resource_collection_id
1256			}
1257		};1196		};
12581197
1259		let resource_collection =1198		<PalletNft<T>>::try_mutate_token_aux_property(
1260			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;1199			collection_id,
1200			nft_id,
1201			PropertyScope::Rmrk,
1202			Self::rmrk_property_key(ResourceId(id))?,
1203			|value| -> DispatchResult {
1204				*value = Some(Self::encode_property(&resource_info)?);
12611205
1262		// todo probably add extra connections to bases, slots, etc., when RMRK starts to use them1206				Ok(())
1207			},
1208		)?;
12631209
1264		let resource_id = Self::create_nft(1210		Ok(id)
1265			&sender,
1266			&nft_owner,
1267			&resource_collection,
1268			resource_properties.chain(
1269				[
1270					Self::rmrk_property(PendingResourceAccept, &pending)?,
1271					Self::rmrk_property(PendingResourceRemoval, &false)?,
1272				]
1273				.into_iter(),
1274			),
1275		)
1276		.map_err(|err| match err {
1277			DispatchError::Arithmetic(_) => <Error<T>>::NoAvailableNftId.into(),
1278			err => Self::map_unique_err_to_proxy(err),
1279		})?;
1280
1281		Ok(resource_id.0)
1282	}1211	}
12831212
1284	fn resource_remove(1213	fn resource_remove(
1285		sender: T::AccountId,1214		sender: T::AccountId,
1286		collection_id: CollectionId,1215		collection_id: CollectionId,
1287		nft_id: TokenId,1216		nft_id: TokenId,
1288		resource_id: TokenId,1217		resource_id: RmrkResourceId,
1289	) -> DispatchResult {1218	) -> DispatchResult {
1290		let collection =1219		let collection =
1291			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;1220			Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
1292		ensure!(collection.owner == sender, Error::<T>::NoPermission);1221		ensure!(collection.owner == sender, Error::<T>::NoPermission);
12931222
1294		let resource_collection_id: Option<CollectionId> =1223		let resource_id_key = Self::rmrk_property_key(ResourceId(resource_id))?;
1295			Self::get_nft_property_decoded(collection_id, nft_id, ResourceCollection)?;1224		let scope = PropertyScope::Rmrk;
12961225
1297		let resource_collection_id =
1298			resource_collection_id.ok_or(Error::<T>::ResourceDoesntExist)?;
1299
1300		let resource_collection =
1301			Self::get_typed_nft_collection(resource_collection_id, misc::CollectionType::Resource)?;
1302		ensure!(1226		ensure!(
1303			<PalletNft<T>>::token_exists(&resource_collection, resource_id),1227			<PalletNft<T>>::token_aux_property((
1228				collection_id,
1229				nft_id,
1230				scope,
1231				resource_id_key.clone()
1232			))
1233			.is_some(),
1304			Error::<T>::ResourceDoesntExist1234			<Error<T>>::ResourceDoesntExist
1305		);1235		);
13061236
1307		let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);1237		let budget = up_data_structs::budget::Value::new(NESTING_BUDGET);
13101240
1311		let sender = T::CrossAccountId::from_sub(sender);1241		let sender = T::CrossAccountId::from_sub(sender);
1312		if topmost_owner == sender {1242		if topmost_owner == sender {
1313			<PalletNft<T>>::burn(&resource_collection, &sender, resource_id)1243			<PalletNft<T>>::remove_token_aux_property(
1314				.map_err(Self::map_unique_err_to_proxy)?;
1315		} else {
1316			<PalletNft<T>>::set_scoped_token_property(
1317				resource_collection_id,1244				collection_id,
1318				resource_id,1245				nft_id,
1319				PropertyScope::Rmrk,1246				PropertyScope::Rmrk,
1320				Self::rmrk_property(PendingResourceRemoval, &true)?,1247				Self::rmrk_property_key(ResourceId(resource_id))?,
1248			);
1249		} else {
1250			Self::try_mutate_resource_info(collection_id, nft_id, resource_id, |res| {
1251				res.pending_removal = true;
1252
1253				Ok(())
1321			)?;1254			})?;
1322		}1255		}
13231256
1324		Ok(())1257		Ok(())
1325	}1258	}
13261259
1260	fn try_mutate_resource_info(
1261		collection_id: CollectionId,
1262		nft_id: TokenId,
1263		resource_id: RmrkResourceId,
1264		f: impl FnOnce(&mut RmrkResourceInfo) -> DispatchResult,
1265	) -> DispatchResult {
1266		<PalletNft<T>>::try_mutate_token_aux_property(
1267			collection_id,
1268			nft_id,
1269			PropertyScope::Rmrk,
1270			Self::rmrk_property_key(ResourceId(resource_id))?,
1271			|value| match value {
1272				Some(value) => {
1273					let mut resource_info: RmrkResourceInfo = Self::decode_property(value)?;
1274
1275					f(&mut resource_info)?;
1276
1277					*value = Self::encode_property(&resource_info)?;
1278
1279					Ok(())
1280				}
1281				None => Err(<Error<T>>::ResourceDoesntExist.into()),
1282			},
1283		)
1284	}
1285
1327	fn change_collection_owner(1286	fn change_collection_owner(
1328		collection_id: CollectionId,1287		collection_id: CollectionId,
1329		collection_type: misc::CollectionType,1288		collection_type: misc::CollectionType,
1339		collection.save()1298		collection.save()
1340	}1299	}
13411300
1342	fn check_collection_owner(1301	pub fn check_collection_owner(
1343		collection: &NonfungibleHandle<T>,1302		collection: &NonfungibleHandle<T>,
1344		account: &T::CrossAccountId,1303		account: &T::CrossAccountId,
1345	) -> DispatchResult {1304	) -> DispatchResult {
1397		collection_id: CollectionId,1356		collection_id: CollectionId,
1398		key: RmrkProperty,1357		key: RmrkProperty,
1399	) -> Result<V, DispatchError> {1358	) -> Result<V, DispatchError> {
1400		Self::decode_property(Self::get_collection_property(collection_id, key)?)1359		Self::decode_property(&Self::get_collection_property(collection_id, key)?)
1401	}1360	}
14021361
1403	pub fn get_collection_type(1362	pub fn get_collection_type(
1404		collection_id: CollectionId,1363		collection_id: CollectionId,
1405	) -> Result<misc::CollectionType, DispatchError> {1364	) -> Result<misc::CollectionType, DispatchError> {
1406		Self::get_collection_property_decoded(collection_id, CollectionType)1365		Self::get_collection_property_decoded(collection_id, CollectionType).map_err(|err| {
1407			.map_err(|_| <Error<T>>::CorruptedCollectionType.into())1366			if err != <Error<T>>::CollectionUnknown.into() {
1367				<Error<T>>::CorruptedCollectionType.into()
1368			} else {
1369				err
1370			}
1371		})
1408	}1372	}
14091373
1410	pub fn ensure_collection_type(1374	pub fn ensure_collection_type(
1450	) -> Result<PropertyValue, DispatchError> {1414	) -> Result<PropertyValue, DispatchError> {
1451		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))1415		let nft_property = <PalletNft<T>>::token_properties((collection_id, nft_id))
1452			.get(&Self::rmrk_property_key(key)?)1416			.get(&Self::rmrk_property_key(key)?)
1453			.ok_or(<Error<T>>::NoAvailableNftId)? // todo replace with better error?1417			.ok_or(<Error<T>>::RmrkPropertyIsNotFound)?
1454			.clone();1418			.clone();
14551419
1456		Ok(nft_property)1420		Ok(nft_property)
1461		nft_id: TokenId,1425		nft_id: TokenId,
1462		key: RmrkProperty,1426		key: RmrkProperty,
1463	) -> Result<V, DispatchError> {1427	) -> Result<V, DispatchError> {
1464		Self::decode_property(Self::get_nft_property(collection_id, nft_id, key)?)1428		Self::decode_property(&Self::get_nft_property(collection_id, nft_id, key)?)
1465	}1429	}
14661430
1467	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {1431	pub fn nft_exists(collection_id: CollectionId, nft_id: TokenId) -> bool {