git.delta.rocks / unique-network / refs/commits / 555e682e0063

18source = "registry+https://github.com/rust-lang/crates.io-index"18source = "registry+https://github.com/rust-lang/crates.io-index"
19checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"19checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
20dependencies = [20dependencies = [
21 "gimli",21 "gimli 0.25.0",
22]22]
23
24[[package]]
25name = "addr2line"
26version = "0.17.0"
27source = "registry+https://github.com/rust-lang/crates.io-index"
28checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
29dependencies = [
30 "gimli 0.26.1",
31]
2332
24[[package]]33[[package]]
25name = "adler"34name = "adler"
385394
386[[package]]395[[package]]
387name = "backtrace"396name = "backtrace"
388version = "0.3.62"397version = "0.3.63"
389source = "registry+https://github.com/rust-lang/crates.io-index"398source = "registry+https://github.com/rust-lang/crates.io-index"
390checksum = "091bcdf2da9950f96aa522681ce805e6857f6ca8df73833d35736ab2dc78e152"399checksum = "321629d8ba6513061f26707241fa9bc89524ff1cd7a915a97ef0c62c666ce1b6"
391dependencies = [400dependencies = [
392 "addr2line",401 "addr2line 0.17.0",
393 "cc",402 "cc",
394 "cfg-if 1.0.0",403 "cfg-if 1.0.0",
395 "libc",404 "libc",
10651074
1066[[package]]1075[[package]]
1067name = "clang-sys"1076name = "clang-sys"
1068version = "1.2.2"1077version = "1.3.0"
1069source = "registry+https://github.com/rust-lang/crates.io-index"1078source = "registry+https://github.com/rust-lang/crates.io-index"
1070checksum = "10612c0ec0e0a1ff0e97980647cb058a6e7aedb913d01d009c406b8b7d0b26ee"1079checksum = "fa66045b9cb23c2e9c1520732030608b02ee07e5cfaa5a521ec15ded7fa24c90"
1071dependencies = [1080dependencies = [
1072 "glob",1081 "glob",
1073 "libc",1082 "libc",
1181 "cranelift-codegen-meta",1190 "cranelift-codegen-meta",
1182 "cranelift-codegen-shared",1191 "cranelift-codegen-shared",
1183 "cranelift-entity",1192 "cranelift-entity",
1184 "gimli",1193 "gimli 0.25.0",
1185 "log",1194 "log",
1186 "regalloc",1195 "regalloc",
1187 "smallvec",1196 "smallvec",
2997 "stable_deref_trait",3006 "stable_deref_trait",
2998]3007]
3008
3009[[package]]
3010name = "gimli"
3011version = "0.26.1"
3012source = "registry+https://github.com/rust-lang/crates.io-index"
3013checksum = "78cc372d058dcf6d5ecd98510e7fbc9e5aec4d21de70f65fea8fecebcd881bd4"
29993014
3000[[package]]3015[[package]]
3001name = "glob"3016name = "glob"
5055 "sp-transaction-pool",5070 "sp-transaction-pool",
5056 "substrate-frame-rpc-system",5071 "substrate-frame-rpc-system",
5057 "tokio 0.2.25",5072 "tokio 0.2.25",
5073 "uc-rpc",
5074 "up-rpc",
5058]5075]
50595076
5060[[package]]5077[[package]]
5082 "nft-data-structs",5099 "nft-data-structs",
5083 "pallet-aura",5100 "pallet-aura",
5084 "pallet-balances",5101 "pallet-balances",
5102 "pallet-common",
5085 "pallet-ethereum",5103 "pallet-ethereum",
5086 "pallet-evm",5104 "pallet-evm",
5087 "pallet-evm-coder-substrate",5105 "pallet-evm-coder-substrate",
5088 "pallet-evm-contract-helpers",5106 "pallet-evm-contract-helpers",
5089 "pallet-evm-migration",5107 "pallet-evm-migration",
5090 "pallet-evm-transaction-payment",5108 "pallet-evm-transaction-payment",
5109 "pallet-fungible",
5091 "pallet-inflation",5110 "pallet-inflation",
5092 "pallet-nft",5111 "pallet-nft",
5093 "pallet-nft-transaction-payment",5112 "pallet-nft-transaction-payment",
5113 "pallet-nonfungible",
5094 "pallet-randomness-collective-flip",5114 "pallet-randomness-collective-flip",
5115 "pallet-refungible",
5095 "pallet-sudo",5116 "pallet-sudo",
5096 "pallet-template-charge-transaction",5117 "pallet-template-charge-transaction",
5097 "pallet-timestamp",5118 "pallet-timestamp",
5121 "sp-transaction-pool",5142 "sp-transaction-pool",
5122 "sp-version",5143 "sp-version",
5123 "substrate-wasm-builder",5144 "substrate-wasm-builder",
5145 "up-rpc",
5124 "xcm",5146 "xcm",
5125 "xcm-builder",5147 "xcm-builder",
5126 "xcm-executor",5148 "xcm-executor",
5537 "sp-std",5559 "sp-std",
5538]5560]
5561
5562[[package]]
5563name = "pallet-common"
5564version = "0.1.0"
5565dependencies = [
5566 "evm-coder",
5567 "frame-support",
5568 "frame-system",
5569 "nft-data-structs",
5570 "pallet-evm",
5571 "pallet-evm-coder-substrate",
5572 "parity-scale-codec",
5573 "scale-info",
5574 "serde",
5575 "sp-core",
5576 "sp-runtime",
5577 "sp-std",
5578]
55395579
5540[[package]]5580[[package]]
5541name = "pallet-contract-helpers"5581name = "pallet-contract-helpers"
5787 "up-sponsorship",5827 "up-sponsorship",
5788]5828]
5829
5830[[package]]
5831name = "pallet-fungible"
5832version = "0.1.0"
5833dependencies = [
5834 "ethereum 0.9.0 (git+https://github.com/purestake/ethereum?branch=joshy-scale-info)",
5835 "evm-coder",
5836 "frame-benchmarking",
5837 "frame-support",
5838 "frame-system",
5839 "nft-data-structs",
5840 "pallet-common",
5841 "pallet-evm-coder-substrate",
5842 "parity-scale-codec",
5843 "scale-info",
5844 "sp-core",
5845 "sp-runtime",
5846 "sp-std",
5847]
57895848
5790[[package]]5849[[package]]
5791name = "pallet-gilt"5850name = "pallet-gilt"
5993 "hex-literal",6052 "hex-literal",
5994 "nft-data-structs",6053 "nft-data-structs",
5995 "pallet-balances",6054 "pallet-balances",
6055 "pallet-common",
5996 "pallet-ethereum",6056 "pallet-ethereum",
5997 "pallet-evm",6057 "pallet-evm",
5998 "pallet-evm-coder-substrate",6058 "pallet-evm-coder-substrate",
6059 "pallet-fungible",
6060 "pallet-nonfungible",
5999 "pallet-randomness-collective-flip",6061 "pallet-randomness-collective-flip",
6062 "pallet-refungible",
6000 "pallet-timestamp",6063 "pallet-timestamp",
6001 "pallet-transaction-payment",6064 "pallet-transaction-payment",
6002 "parity-scale-codec",6065 "parity-scale-codec",
6044 "sp-std",6107 "sp-std",
6045]6108]
6109
6110[[package]]
6111name = "pallet-nonfungible"
6112version = "0.1.0"
6113dependencies = [
6114 "ethereum 0.9.0 (git+https://github.com/purestake/ethereum?branch=joshy-scale-info)",
6115 "evm-coder",
6116 "frame-benchmarking",
6117 "frame-support",
6118 "frame-system",
6119 "nft-data-structs",
6120 "pallet-common",
6121 "pallet-evm-coder-substrate",
6122 "parity-scale-codec",
6123 "scale-info",
6124 "sp-core",
6125 "sp-runtime",
6126 "sp-std",
6127]
60466128
6047[[package]]6129[[package]]
6048name = "pallet-offences"6130name = "pallet-offences"
6127 "sp-std",6209 "sp-std",
6128]6210]
6211
6212[[package]]
6213name = "pallet-refungible"
6214version = "0.1.0"
6215dependencies = [
6216 "frame-benchmarking",
6217 "frame-support",
6218 "frame-system",
6219 "nft-data-structs",
6220 "pallet-common",
6221 "parity-scale-codec",
6222 "scale-info",
6223 "sp-core",
6224 "sp-runtime",
6225 "sp-std",
6226]
61296227
6130[[package]]6228[[package]]
6131name = "pallet-scheduler"6229name = "pallet-scheduler"
64706568
6471[[package]]6569[[package]]
6472name = "parity-db"6570name = "parity-db"
6473version = "0.3.2"6571version = "0.3.3"
6474source = "registry+https://github.com/rust-lang/crates.io-index"6572source = "registry+https://github.com/rust-lang/crates.io-index"
6475checksum = "91b679c6acc14fac74382942e2b73bea441686a33430b951ea03b5aeb6a7f254"6573checksum = "e7ccc4a8687027deb53d45c5434a1f1b330c9d1069a59cfe80a62aa9a1da25ae"
6476dependencies = [6574dependencies = [
6477 "blake2-rfc",6575 "blake2-rfc",
6478 "crc32fast",6576 "crc32fast",
11609source = "registry+https://github.com/rust-lang/crates.io-index"11707source = "registry+https://github.com/rust-lang/crates.io-index"
11610checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"11708checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
11709
11710[[package]]
11711name = "uc-rpc"
11712version = "0.1.0"
11713dependencies = [
11714 "jsonrpc-core",
11715 "jsonrpc-core-client",
11716 "jsonrpc-derive",
11717 "nft-data-structs",
11718 "pallet-common",
11719 "parity-scale-codec",
11720 "sp-api",
11721 "sp-blockchain",
11722 "sp-core",
11723 "sp-rpc",
11724 "sp-runtime",
11725 "up-rpc",
11726]
1161111727
11612[[package]]11728[[package]]
11613name = "ucd-trie"11729name = "ucd-trie"
11715source = "registry+https://github.com/rust-lang/crates.io-index"11831source = "registry+https://github.com/rust-lang/crates.io-index"
11716checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"11832checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
11833
11834[[package]]
11835name = "up-rpc"
11836version = "0.1.0"
11837dependencies = [
11838 "nft-data-structs",
11839 "pallet-common",
11840 "parity-scale-codec",
11841 "sp-api",
11842 "sp-core",
11843 "sp-runtime",
11844 "sp-std",
11845]
1171711846
11718[[package]]11847[[package]]
11719name = "up-sponsorship"11848name = "up-sponsorship"
12007 "cranelift-frontend",12136 "cranelift-frontend",
12008 "cranelift-native",12137 "cranelift-native",
12009 "cranelift-wasm",12138 "cranelift-wasm",
12010 "gimli",12139 "gimli 0.25.0",
12011 "more-asserts",12140 "more-asserts",
12012 "object 0.26.2",12141 "object 0.26.2",
12013 "target-lexicon",12142 "target-lexicon",
12025 "anyhow",12154 "anyhow",
12026 "cfg-if 1.0.0",12155 "cfg-if 1.0.0",
12027 "cranelift-entity",12156 "cranelift-entity",
12028 "gimli",12157 "gimli 0.25.0",
12029 "indexmap",12158 "indexmap",
12030 "log",12159 "log",
12031 "more-asserts",12160 "more-asserts",
12043source = "registry+https://github.com/rust-lang/crates.io-index"12172source = "registry+https://github.com/rust-lang/crates.io-index"
12044checksum = "24f46dd757225f29a419be415ea6fb8558df9b0194f07e3a6a9c99d0e14dd534"12173checksum = "24f46dd757225f29a419be415ea6fb8558df9b0194f07e3a6a9c99d0e14dd534"
12045dependencies = [12174dependencies = [
12046 "addr2line",12175 "addr2line 0.16.0",
12047 "anyhow",12176 "anyhow",
12048 "bincode",12177 "bincode",
12049 "cfg-if 1.0.0",12178 "cfg-if 1.0.0",
12050 "gimli",12179 "gimli 0.25.0",
12051 "libc",12180 "libc",
12052 "log",12181 "log",
12053 "more-asserts",12182 "more-asserts",

75	) -> Result<String>;75	) -> Result<String>;
7676
77	#[rpc(name = "nft_adminlist")]77	#[rpc(name = "nft_adminlist")]
78	fn adminlist(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<Vec<AccountId>>;78	fn adminlist(
79		&self,
80		collection: CollectionId,
81		at: Option<BlockHash>,
82	) -> Result<Vec<CrossAccountId>>;
79	#[rpc(name = "nft_allowlist")]83	#[rpc(name = "nft_allowlist")]
80	fn allowlist(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<Vec<AccountId>>;84	fn allowlist(
85		&self,
86		collection: CollectionId,
87		at: Option<BlockHash>,
88	) -> Result<Vec<CrossAccountId>>;
81	#[rpc(name = "nft_lastTokenId")]89	#[rpc(name = "nft_lastTokenId")]
82	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;90	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;
83}91}
150	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string());158	pass_method!(balance(collection: CollectionId, account: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
151	pass_method!(allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string());159	pass_method!(allowance(collection: CollectionId, sender: CrossAccountId, spender: CrossAccountId, token: TokenId) -> String => |v| v.to_string());
152160
153	pass_method!(adminlist(collection: CollectionId) -> Vec<AccountId>);161	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);
154	pass_method!(allowlist(collection: CollectionId) -> Vec<AccountId>);162	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);
155	pass_method!(last_token_id(collection: CollectionId) -> TokenId);163	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
156}164}
157165

9                "rpcPort": 9843,9                "rpcPort": 9843,
10                "port": 30444,10                "port": 30444,
11                "flags": [11                "flags": [
12                    "--rpc-port=9843"12                    "--rpc-port=9843",
13                    "-lparachain::candidate_validation=debug"
13                ]14                ]
14            },15            },
15            {16            {
18                "rpcPort": 9854,19                "rpcPort": 9854,
19                "port": 30555,20                "port": 30555,
20                "flags": [21                "flags": [
21                    "--rpc-port=9854"22                    "--rpc-port=9854",
23                    "-lparachain::candidate_validation=debug"
22                ]24                ]
23            },25            },
24            {26            {
27                "rpcPort": 9865,29                "rpcPort": 9865,
28                "port": 30666,30                "port": 30666,
29                "flags": [31                "flags": [
30                    "--rpc-port=9865"32                    "--rpc-port=9865",
33                    "-lparachain::candidate_validation=debug"
31                ]34                ]
32            },35            },
33            {36            {
36                "rpcPort": 9876,39                "rpcPort": 9876,
37                "port": 30777,40                "port": 30777,
38                "flags": [41                "flags": [
39                    "--rpc-port=9876"42                    "--rpc-port=9876",
43                    "-lparachain::candidate_validation=debug"
40                ]44                ]
41            }45            }
42        ],46        ],

20	fn from_sub(account: AccountId) -> Self;20	fn from_sub(account: AccountId) -> Self;
21	fn from_eth(account: H160) -> Self;21	fn from_eth(account: H160) -> Self;
22
23	fn conv_eq(&self, other: &Self) -> bool;
22}24}
2325
24#[derive(Encode, Decode, Serialize, Deserialize, TypeInfo)]26#[derive(Encode, Decode, Serialize, Deserialize, TypeInfo)]
28	Ethereum(H160),30	Ethereum(H160),
29}31}
3032
31#[derive(Eq)]33#[derive(PartialEq, Eq)]
32pub struct BasicCrossAccountId<T: Config> {34pub struct BasicCrossAccountId<T: Config> {
33	/// If true - then ethereum is canonical encoding35	/// If true - then ethereum is canonical encoding
34	from_ethereum: bool,36	from_ethereum: bool,
77	}79	}
78}80}
7981
80impl<T: Config> PartialEq for BasicCrossAccountId<T> {
81	fn eq(&self, other: &Self) -> bool {
82		if self.from_ethereum == other.from_ethereum {
83			self.substrate == other.substrate && self.ethereum == other.ethereum
84		} else if self.from_ethereum {
85			// ethereum is canonical encoding, but we need to compare derived address
86			self.substrate == other.substrate
87		} else {
88			self.ethereum == other.ethereum
89		}
90	}
91}
92impl<T: Config> Clone for BasicCrossAccountId<T> {82impl<T: Config> Clone for BasicCrossAccountId<T> {
93	fn clone(&self) -> Self {83	fn clone(&self) -> Self {
94		Self {84		Self {
158			from_ethereum: true,148			from_ethereum: true,
159		}149		}
160	}150	}
151	fn conv_eq(&self, other: &Self) -> bool {
152		if self.from_ethereum == other.from_ethereum {
153			self.substrate == other.substrate && self.ethereum == other.ethereum
154		} else if self.from_ethereum {
155			// ethereum is canonical encoding, but we need to compare derived address
156			self.substrate == other.substrate
157		} else {
158			self.ethereum == other.ethereum
159		}
160	}
161}161}
162impl<T: Config> From<BasicCrossAccountIdRepr<T::AccountId>> for BasicCrossAccountId<T> {162impl<T: Config> From<BasicCrossAccountIdRepr<T::AccountId>> for BasicCrossAccountId<T> {
163	fn from(repr: BasicCrossAccountIdRepr<T::AccountId>) -> Self {163	fn from(repr: BasicCrossAccountIdRepr<T::AccountId>) -> Self {

11use nft_data_structs::{11use nft_data_structs::{
12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,
13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
14	MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight, WithdrawReasons,14	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight,
15	WithdrawReasons,
15};16};
16pub use pallet::*;17pub use pallet::*;
98	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> Result<bool, DispatchError> {99	pub fn is_owner_or_admin(&self, subject: &T::CrossAccountId) -> Result<bool, DispatchError> {
99		self.consume_sload()?;100		self.consume_sload()?;
100101
101		Ok(*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject.as_sub())))102		Ok(*subject.as_sub() == self.owner || <IsAdmin<T>>::get((self.id, subject)))
102	}103	}
103	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {104	pub fn check_is_owner_or_admin(&self, subject: &T::CrossAccountId) -> DispatchResult {
104		ensure!(self.is_owner_or_admin(subject)?, <Error<T>>::NoPermission);105		ensure!(self.is_owner_or_admin(subject)?, <Error<T>>::NoPermission);
105		Ok(())106		Ok(())
106	}107	}
107	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {108	pub fn ignores_allowance(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {
108		Ok(self.limits.owner_can_transfer && self.is_owner_or_admin(user)?)109		Ok(self.limits.owner_can_transfer() && self.is_owner_or_admin(user)?)
109	}110	}
110	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {111	pub fn ignores_owned_amount(&self, user: &T::CrossAccountId) -> Result<bool, DispatchError> {
111		Ok(self.limits.owner_can_transfer && self.is_owner_or_admin(user)?)112		Ok(self.limits.owner_can_transfer() && self.is_owner_or_admin(user)?)
112	}113	}
113	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {114	pub fn check_allowlist(&self, user: &T::CrossAccountId) -> DispatchResult {
114		self.consume_sload()?;115		self.consume_sload()?;
115116
116		ensure!(117		ensure!(
117			<Allowlist<T>>::get((self.id, user.as_sub())),118			<Allowlist<T>>::get((self.id, user)),
118			<Error<T>>::AddressNotInAllowlist119			<Error<T>>::AddressNotInAllowlist
119		);120		);
120		Ok(())121		Ok(())
139#[frame_support::pallet]140#[frame_support::pallet]
140pub mod pallet {141pub mod pallet {
141	use super::*;142	use super::*;
142	use frame_support::{pallet_prelude::*};
143	use frame_support::{Blake2_128Concat, storage::Key};143	use frame_support::{Blake2_128Concat, pallet_prelude::*, storage::Key};
144	use account::{EvmBackwardsAddressMapping, CrossAccountId};144	use account::{EvmBackwardsAddressMapping, CrossAccountId};
145	use frame_support::traits::Currency;145	use frame_support::traits::Currency;
146	use nft_data_structs::TokenId;146	use nft_data_structs::TokenId;
166	#[pallet::generate_store(pub(super) trait Store)]166	#[pallet::generate_store(pub(super) trait Store)]
167	pub struct Pallet<T>(_);167	pub struct Pallet<T>(_);
168
169	#[pallet::extra_constants]
170	impl<T: Config> Pallet<T> {
171		pub fn collection_admins_limit() -> u32 {
172			COLLECTION_ADMINS_LIMIT
173		}
174	}
168175
169	#[pallet::event]176	#[pallet::event]
170	#[pallet::generate_deposit(pub fn deposit_event)]177	#[pallet::generate_deposit(pub fn deposit_event)]
266		TotalCollectionsLimitExceeded,273		TotalCollectionsLimitExceeded,
267		/// variable_data exceeded data limit.274		/// variable_data exceeded data limit.
268		TokenVariableDataLimitExceeded,275		TokenVariableDataLimitExceeded,
276		/// Exceeded max admin amount
277		CollectionAdminAmountExceeded,
269278
270		/// Collection settings not allowing items transferring279		/// Collection settings not allowing items transferring
271		TransferNotAllowed,280		TransferNotAllowed,
306		QueryKind = OptionQuery,315		QueryKind = OptionQuery,
307	>;316	>;
317
318	#[pallet::storage]
319	pub type AdminAmount<T> = StorageMap<
320		Hasher = Blake2_128Concat,
321		Key = CollectionId,
322		Value = u32,
323		QueryKind = ValueQuery,
324	>;
308325
309	/// List of collection admins326	/// List of collection admins
310	#[pallet::storage]327	#[pallet::storage]
311	pub type IsAdmin<T: Config> = StorageNMap<328	pub type IsAdmin<T: Config> = StorageNMap<
312		Key = (329		Key = (
313			Key<Blake2_128Concat, CollectionId>,330			Key<Blake2_128Concat, CollectionId>,
314			Key<Blake2_128Concat, T::AccountId>,331			Key<Blake2_128Concat, T::CrossAccountId>,
315		),332		),
316		Value = bool,333		Value = bool,
317		QueryKind = ValueQuery,334		QueryKind = ValueQuery,
322	pub type Allowlist<T: Config> = StorageNMap<339	pub type Allowlist<T: Config> = StorageNMap<
323		Key = (340		Key = (
324			Key<Blake2_128Concat, CollectionId>,341			Key<Blake2_128Concat, CollectionId>,
325			Key<Blake2_128Concat, T::AccountId>,342			Key<Blake2_128Concat, T::CrossAccountId>,
326		),343		),
327		Value = bool,344		Value = bool,
328		QueryKind = ValueQuery,345		QueryKind = ValueQuery,
405		collection: CollectionHandle<T>,422		collection: CollectionHandle<T>,
406		sender: &T::CrossAccountId,423		sender: &T::CrossAccountId,
407	) -> DispatchResult {424	) -> DispatchResult {
408		if !collection.limits.owner_can_destroy {
409			fail!(Error::<T>::NoPermission);425		ensure!(
410		}426			collection.limits.owner_can_destroy(),
427			<Error<T>>::NoPermission,
428		);
411		collection.check_is_owner(&sender)?;429		collection.check_is_owner(&sender)?;
412430
419437
420		<DestroyedCollectionCount<T>>::put(destroyed_collections);438		<DestroyedCollectionCount<T>>::put(destroyed_collections);
421		<CollectionById<T>>::remove(collection.id);439		<CollectionById<T>>::remove(collection.id);
440		<AdminAmount<T>>::remove(collection.id);
422		<IsAdmin<T>>::remove_prefix((collection.id,), None);441		<IsAdmin<T>>::remove_prefix((collection.id,), None);
423		<Allowlist<T>>::remove_prefix((collection.id,), None);442		<Allowlist<T>>::remove_prefix((collection.id,), None);
424		Ok(())443		Ok(())
435		// =========454		// =========
436455
437		if allowed {456		if allowed {
438			<Allowlist<T>>::insert((collection.id, user.as_sub()), true);457			<Allowlist<T>>::insert((collection.id, user), true);
439		} else {458		} else {
440			<Allowlist<T>>::remove((collection.id, user.as_sub()));459			<Allowlist<T>>::remove((collection.id, user));
441		}460		}
442461
443		Ok(())462		Ok(())
444	}463	}
464
465	pub fn toggle_admin(
466		collection: &CollectionHandle<T>,
467		sender: &T::CrossAccountId,
468		user: &T::CrossAccountId,
469		admin: bool,
470	) -> DispatchResult {
471		collection.check_is_owner_or_admin(&sender)?;
472
473		let was_admin = <IsAdmin<T>>::get((collection.id, user));
474		if was_admin == admin {
475			return Ok(());
476		}
477		let amount = <AdminAmount<T>>::get(collection.id);
478
479		if admin {
480			let amount = amount
481				.checked_add(1)
482				.ok_or(<Error<T>>::CollectionAdminAmountExceeded)?;
483			ensure!(
484				amount <= Self::collection_admins_limit(),
485				<Error<T>>::CollectionAdminAmountExceeded,
486			);
487
488			// =========
489
490			<AdminAmount<T>>::insert(collection.id, amount);
491			<IsAdmin<T>>::insert((collection.id, user), true);
492		} else {
493			<AdminAmount<T>>::insert(collection.id, amount.saturating_sub(1));
494			<IsAdmin<T>>::remove((collection.id, user));
495		}
496
497		Ok(())
498	}
445}499}
446500
447#[macro_export]501#[macro_export]

3use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};3use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
4use nft_data_structs::TokenId;4use nft_data_structs::TokenId;
5use pallet_common::{5use pallet_common::{CommonCollectionOperations, CommonWeightInfo, with_weight};
6	CommonCollectionOperations, CommonWeightInfo, account::CrossAccountId, with_weight,
7};
8use sp_runtime::ArithmeticError;6use sp_runtime::ArithmeticError;
9use sp_std::{vec::Vec, vec};7use sp_std::{vec::Vec, vec};
188	}186	}
189187
190	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {188	fn account_tokens(&self, account: T::CrossAccountId) -> Vec<TokenId> {
191		if <Balance<T>>::get((self.id, account.as_sub())) != 0 {189		if <Balance<T>>::get((self.id, account)) != 0 {
192			vec![TokenId::default()]190			vec![TokenId::default()]
193		} else {191		} else {
194			vec![]192			vec![]
218	}216	}
219217
220	fn account_balance(&self, account: T::CrossAccountId) -> u32 {218	fn account_balance(&self, account: T::CrossAccountId) -> u32 {
221		if <Balance<T>>::get((self.id, account.as_sub())) != 0 {219		if <Balance<T>>::get((self.id, account)) != 0 {
222			1220			1
223		} else {221		} else {
224			0222			0
229		if token != TokenId::default() {227		if token != TokenId::default() {
230			return 0;228			return 0;
231		}229		}
232		<Balance<T>>::get((self.id, account.as_sub()))230		<Balance<T>>::get((self.id, account))
233	}231	}
234232
235	fn allowance(233	fn allowance(
241		if token != TokenId::default() {239		if token != TokenId::default() {
242			return 0;240			return 0;
243		}241		}
244		<Allowance<T>>::get((self.id, sender.as_sub(), spender.as_sub()))242		<Allowance<T>>::get((self.id, sender, spender))
245	}243	}
246}244}
247245

52	}52	}
53	fn balance_of(&self, owner: address) -> Result<uint256> {53	fn balance_of(&self, owner: address) -> Result<uint256> {
54		let owner = T::CrossAccountId::from_eth(owner);54		let owner = T::CrossAccountId::from_eth(owner);
55		let balance = <Balance<T>>::get((self.id, owner.as_sub()));55		let balance = <Balance<T>>::get((self.id, owner));
56		Ok(balance.into())56		Ok(balance.into())
57	}57	}
58	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {58	fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
92		let owner = T::CrossAccountId::from_eth(owner);92		let owner = T::CrossAccountId::from_eth(owner);
93		let spender = T::CrossAccountId::from_eth(spender);93		let spender = T::CrossAccountId::from_eth(spender);
9494
95		Ok(<Allowance<T>>::get((self.id, owner.as_sub(), spender.as_sub())).into())95		Ok(<Allowance<T>>::get((self.id, owner, spender)).into())
96	}96	}
97}97}
9898

55	pub(super) type Balance<T: Config> = StorageNMap<55	pub(super) type Balance<T: Config> = StorageNMap<
56		Key = (56		Key = (
57			Key<Twox64Concat, CollectionId>,57			Key<Twox64Concat, CollectionId>,
58			Key<Blake2_128Concat, T::AccountId>,58			Key<Blake2_128Concat, T::CrossAccountId>,
59		),59		),
60		Value = u128,60		Value = u128,
61		QueryKind = ValueQuery,61		QueryKind = ValueQuery,
65	pub(super) type Allowance<T: Config> = StorageNMap<65	pub(super) type Allowance<T: Config> = StorageNMap<
66		Key = (66		Key = (
67			Key<Twox64Concat, CollectionId>,67			Key<Twox64Concat, CollectionId>,
68			Key<Blake2_128, T::AccountId>,68			Key<Blake2_128, T::CrossAccountId>,
69			Key<Blake2_128Concat, T::AccountId>,69			Key<Blake2_128Concat, T::CrossAccountId>,
70		),70		),
71		Value = u128,71		Value = u128,
72		QueryKind = ValueQuery,72		QueryKind = ValueQuery,
119			.checked_sub(amount)119			.checked_sub(amount)
120			.ok_or(<CommonError<T>>::TokenValueTooLow)?;120			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
121121
122		let balance = <Balance<T>>::get((collection.id, owner.as_sub()))122		let balance = <Balance<T>>::get((collection.id, owner))
123			.checked_sub(amount)123			.checked_sub(amount)
124			.ok_or(<CommonError<T>>::TokenValueTooLow)?;124			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
125125
130		// =========130		// =========
131131
132		if balance == 0 {132		if balance == 0 {
133			<Balance<T>>::remove((collection.id, owner.as_sub()));133			<Balance<T>>::remove((collection.id, owner));
134		} else {134		} else {
135			<Balance<T>>::insert((collection.id, owner.as_sub()), balance);135			<Balance<T>>::insert((collection.id, owner), balance);
136		}136		}
137		<TotalSupply<T>>::insert(collection.id, total_supply);137		<TotalSupply<T>>::insert(collection.id, total_supply);
138138
157		amount: u128,157		amount: u128,
158	) -> DispatchResult {158	) -> DispatchResult {
159		ensure!(159		ensure!(
160			collection.transfers_enabled,160			collection.limits.transfers_enabled(),
161			<CommonError<T>>::TransferNotAllowed161			<CommonError<T>>::TransferNotAllowed,
162		);162		);
163163
164		if collection.access == AccessMode::WhiteList {164		if collection.access == AccessMode::WhiteList {
167		}167		}
168		<PalletCommon<T>>::ensure_correct_receiver(to)?;168		<PalletCommon<T>>::ensure_correct_receiver(to)?;
169169
170		let balance_from = <Balance<T>>::get((collection.id, from.as_sub()))170		let balance_from = <Balance<T>>::get((collection.id, from))
171			.checked_sub(amount)171			.checked_sub(amount)
172			.ok_or(<CommonError<T>>::TokenValueTooLow)?;172			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
173		let balance_to = if from != to {173		let balance_to = if from != to {
174			Some(174			Some(
175				<Balance<T>>::get((collection.id, to.as_sub()))175				<Balance<T>>::get((collection.id, to))
176					.checked_add(amount)176					.checked_add(amount)
177					.ok_or(ArithmeticError::Overflow)?,177					.ok_or(ArithmeticError::Overflow)?,
178			)178			)
190		if let Some(balance_to) = balance_to {190		if let Some(balance_to) = balance_to {
191			// from != to191			// from != to
192			if balance_from == 0 {192			if balance_from == 0 {
193				<Balance<T>>::remove((collection.id, from.as_sub()));193				<Balance<T>>::remove((collection.id, from));
194			} else {194			} else {
195				<Balance<T>>::insert((collection.id, from.as_sub()), balance_from);195				<Balance<T>>::insert((collection.id, from), balance_from);
196			}196			}
197			<Balance<T>>::insert((collection.id, to.as_sub()), balance_to);197			<Balance<T>>::insert((collection.id, to), balance_to);
198		}198		}
199199
200		collection.log_infallible(ERC20Events::Transfer {200		collection.log_infallible(ERC20Events::Transfer {
235		let total_supply = data235		let total_supply = data
236			.iter()236			.iter()
237			.map(|u| u.1)237			.map(|u| u.1)
238			.try_fold(0u128, |acc, v| acc.checked_add(v))238			.try_fold(<TotalSupply<T>>::get(collection.id), |acc, v| {
239				acc.checked_add(v)
240			})
239			.ok_or(ArithmeticError::Overflow)?;241			.ok_or(ArithmeticError::Overflow)?;
240242
241		for (user, amount) in data.into_iter() {243		for (user, amount) in data.into_iter() {
242			collection.consume_sload()?;244			collection.consume_sload()?;
243			let balance = balances245			let balance = balances
244				.entry(user.clone())246				.entry(user.clone())
245				.or_insert_with(|| <Balance<T>>::get((collection.id, user.as_sub())));247				.or_insert_with(|| <Balance<T>>::get((collection.id, user)));
246			*balance = (*balance)248			*balance = (*balance)
247				.checked_add(amount)249				.checked_add(amount)
248				.ok_or(ArithmeticError::Overflow)?;250				.ok_or(ArithmeticError::Overflow)?;
259261
260		<TotalSupply<T>>::insert(collection.id, total_supply);262		<TotalSupply<T>>::insert(collection.id, total_supply);
261		for (user, amount) in balances {263		for (user, amount) in balances {
262			<Balance<T>>::insert((collection.id, user.as_sub()), amount);264			<Balance<T>>::insert((collection.id, &user), amount);
263265
264			collection.log_infallible(ERC20Events::Transfer {266			collection.log_infallible(ERC20Events::Transfer {
265				from: H160::default(),267				from: H160::default(),
283		spender: &T::CrossAccountId,285		spender: &T::CrossAccountId,
284		amount: u128,286		amount: u128,
285	) {287	) {
286		<Allowance<T>>::insert((collection.id, owner.as_sub(), spender.as_sub()), amount);288		<Allowance<T>>::insert((collection.id, owner, spender), amount);
287289
288		collection.log_infallible(ERC20Events::Approval {290		collection.log_infallible(ERC20Events::Approval {
289			owner: *owner.as_eth(),291			owner: *owner.as_eth(),
310			collection.check_allowlist(&spender)?;312			collection.check_allowlist(&spender)?;
311		}313		}
312314
313		if <Balance<T>>::get((collection.id, owner.as_sub())) < amount {315		if <Balance<T>>::get((collection.id, owner)) < amount {
314			ensure!(316			ensure!(
315				collection.ignores_owned_amount(owner)?,317				collection.ignores_owned_amount(owner)?,
316				<CommonError<T>>::CantApproveMoreThanOwned318				<CommonError<T>>::CantApproveMoreThanOwned
330		to: &T::CrossAccountId,332		to: &T::CrossAccountId,
331		amount: u128,333		amount: u128,
332	) -> DispatchResult {334	) -> DispatchResult {
333		if spender == from {335		if spender.conv_eq(from) {
334			return Self::transfer(collection, from, to, amount);336			return Self::transfer(collection, from, to, amount);
335		}337		}
336		if collection.access == AccessMode::WhiteList {338		if collection.access == AccessMode::WhiteList {
337			// `from`, `to` checked in [`transfer`]339			// `from`, `to` checked in [`transfer`]
338			collection.check_allowlist(spender)?;340			collection.check_allowlist(spender)?;
339		}341		}
340342
341		let allowance = <Allowance<T>>::get((collection.id, from.as_sub(), spender.as_sub()))343		let allowance = <Allowance<T>>::get((collection.id, from, spender)).checked_sub(amount);
342			.checked_sub(amount);
343		if allowance.is_none() {344		if allowance.is_none() {
344			ensure!(345			ensure!(
362		from: &T::CrossAccountId,363		from: &T::CrossAccountId,
363		amount: u128,364		amount: u128,
364	) -> DispatchResult {365	) -> DispatchResult {
365		if spender == from {366		if spender.conv_eq(from) {
366			return Self::burn(collection, from, amount);367			return Self::burn(collection, from, amount);
367		}368		}
368		if collection.access == AccessMode::WhiteList {369		if collection.access == AccessMode::WhiteList {
369			// `from` checked in [`burn`]370			// `from` checked in [`burn`]
370			collection.check_allowlist(spender)?;371			collection.check_allowlist(spender)?;
371		}372		}
372373
373		let allowance = <Allowance<T>>::get((collection.id, from.as_sub(), spender.as_sub()))374		let allowance = <Allowance<T>>::get((collection.id, from, spender)).checked_sub(amount);
374			.checked_sub(amount);
375		if allowance.is_none() {375		if allowance.is_none() {
376			ensure!(376			ensure!(