git.delta.rocks / unique-network / refs/commits / 590af3c94d5b

110110
111/// Helper function to generate a crypto pair from seed111/// Helper function to generate a crypto pair from seed
112pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {112pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
113	TPublic::Pair::from_string(&format!("//{}", seed), None)113	TPublic::Pair::from_string(&format!("//{seed}"), None)
114		.expect("static values are valid; qed")114		.expect("static values are valid; qed")
115		.public()115		.public()
116}116}

83		"" | "local" => Box::new(chain_spec::local_testnet_config()),83		"" | "local" => Box::new(chain_spec::local_testnet_config()),
84		path => {84		path => {
85			let path = std::path::PathBuf::from(path);85			let path = std::path::PathBuf::from(path);
86			let chain_spec = Box::new(chain_spec::OpalChainSpec::from_json_file(path.clone())?)86			let chain_spec = Box::new(chain_spec::OpalChainSpec::from_json_file(path)?)
87				as Box<dyn sc_service::ChainSpec>;87				as Box<dyn sc_service::ChainSpec>;
8888
89			match chain_spec.runtime_id() {89			match chain_spec.runtime_id() {
352					&polkadot_cli,352					&polkadot_cli,
353					config.tokio_handle.clone(),353					config.tokio_handle.clone(),
354				)354				)
355				.map_err(|err| format!("Relay chain argument error: {}", err))?;355				.map_err(|err| format!("Relay chain argument error: {err}"))?;
356356
357				cmd.run(config, polkadot_config)357				cmd.run(config, polkadot_config)
358			})358			})
464			runner.run_node_until_exit(|config| async move {464			runner.run_node_until_exit(|config| async move {
465				let hwbench = if !cli.no_hardware_benchmarks {465				let hwbench = if !cli.no_hardware_benchmarks {
466					config.database.path().map(|database_path| {466					config.database.path().map(|database_path| {
467						let _ = std::fs::create_dir_all(&database_path);467						let _ = std::fs::create_dir_all(database_path);
468						sc_sysinfo::gather_hwbench(Some(database_path))468						sc_sysinfo::gather_hwbench(Some(database_path))
469					})469					})
470				} else {470				} else {
512512
513				let state_version = Cli::native_runtime_version(&config.chain_spec).state_version();513				let state_version = Cli::native_runtime_version(&config.chain_spec).state_version();
514				let block: Block = generate_genesis_block(&*config.chain_spec, state_version)514				let block: Block = generate_genesis_block(&*config.chain_spec, state_version)
515					.map_err(|e| format!("{:?}", e))?;515					.map_err(|e| format!("{e:?}"))?;
516				let genesis_state = format!("0x{:?}", HexDisplay::from(&block.header().encode()));516				let genesis_state = format!("0x{:?}", HexDisplay::from(&block.header().encode()));
517				let genesis_hash = format!("0x{:?}", HexDisplay::from(&block.header().hash().0));517				let genesis_hash = format!("0x{:?}", HexDisplay::from(&block.header().hash().0));
518518
521					&polkadot_cli,521					&polkadot_cli,
522					config.tokio_handle.clone(),522					config.tokio_handle.clone(),
523				)523				)
524				.map_err(|err| format!("Relay chain argument error: {}", err))?;524				.map_err(|err| format!("Relay chain argument error: {err}"))?;
525525
526				info!("Parachain id: {:?}", para_id);526				info!("Parachain id: {:?}", para_id);
527				info!("Parachain Account: {}", parachain_account);527				info!("Parachain Account: {}", parachain_account);

698{698{
699	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;699	let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;
700700
701	let block_import = ParachainBlockImport::new(client.clone(), backend.clone());701	let block_import = ParachainBlockImport::new(client.clone(), backend);
702702
703	cumulus_client_consensus_aura::import_queue::<703	cumulus_client_consensus_aura::import_queue::<
704		sp_consensus_aura::sr25519::AuthorityPair,704		sp_consensus_aura::sr25519::AuthorityPair,
709		_,709		_,
710	>(cumulus_client_consensus_aura::ImportQueueParams {710	>(cumulus_client_consensus_aura::ImportQueueParams {
711		block_import,711		block_import,
712		client: client.clone(),712		client,
713		create_inherent_data_providers: move |_, _| async move {713		create_inherent_data_providers: move |_, _| async move {
714			let time = sp_timestamp::InherentDataProvider::from_system_time();714			let time = sp_timestamp::InherentDataProvider::from_system_time();
715715
787				telemetry.clone(),787				telemetry.clone(),
788			);788			);
789789
790			let block_import = ParachainBlockImport::new(client.clone(), backend.clone());790			let block_import = ParachainBlockImport::new(client.clone(), backend);
791791
792			Ok(AuraConsensus::build::<792			Ok(AuraConsensus::build::<
793				sp_consensus_aura::sr25519::AuthorityPair,793				sp_consensus_aura::sr25519::AuthorityPair,
864	ExecutorDispatch: NativeExecutionDispatch + 'static,864	ExecutorDispatch: NativeExecutionDispatch + 'static,
865{865{
866	Ok(sc_consensus_manual_seal::import_queue(866	Ok(sc_consensus_manual_seal::import_queue(
867		Box::new(client.clone()),867		Box::new(client),
868		&task_manager.spawn_essential_handle(),868		&task_manager.spawn_essential_handle(),
869		config.prometheus_registry(),869		config.prometheus_registry(),
870	))870	))
956956
957	let collator = config.role.is_authority();957	let collator = config.role.is_authority();
958958
959	let select_chain = maybe_select_chain.clone();959	let select_chain = maybe_select_chain;
960960
961	if collator {961	if collator {
962		let block_import =962		let block_import =

289	io.merge(289	io.merge(
290		Net::new(290		Net::new(
291			client.clone(),291			client.clone(),
292			network.clone(),292			network,
293			// Whether to format the `peer_count` response as Hex (default) or not.293			// Whether to format the `peer_count` response as Hex (default) or not.
294			true,294			true,
295		)295		)

296296
297			if !block_pending.is_empty() {297			if !block_pending.is_empty() {
298				block_pending.into_iter().for_each(|(staker, amount)| {298				block_pending.into_iter().for_each(|(staker, amount)| {
299					Self::get_frozen_balance(&staker).map(|b| {299					if let Some(b) = Self::get_frozen_balance(&staker) {
300						let new_state = b.checked_sub(&amount).unwrap_or_default();300						let new_state = b.checked_sub(&amount).unwrap_or_default();
301301
302						// In this case, setting a new state for the frozen funds cannot fail302						// In this case, setting a new state for the frozen funds cannot fail
305						// that we cannot (in the current implementation) unfreeze more funds305						// that we cannot (in the current implementation) unfreeze more funds
306						// than were originally frozen by the pallet. Either way, `on_initialize()` cannot fail.306						// than were originally frozen by the pallet. Either way, `on_initialize()` cannot fail.
307						Self::set_freeze_unchecked(&staker, new_state);307						Self::set_freeze_unchecked(&staker, new_state);
308					});308					};
309				});309				});
310			}310			}
311311
598			// this value is set for the stakers to whom the recalculation will be performed598			// this value is set for the stakers to whom the recalculation will be performed
599			let next_recalc_block = current_recalc_block + config.recalculation_interval;599			let next_recalc_block = current_recalc_block + config.recalculation_interval;
600600
601			let mut storage_iterator = Self::get_next_calculated_key()601			let storage_iterator =
602				.map_or(Staked::<T>::iter(), |key| Staked::<T>::iter_from(key));602				Self::get_next_calculated_key().map_or(Staked::<T>::iter(), Staked::<T>::iter_from);
603603
604			PreviousCalculatedRecord::<T>::set(None);604			PreviousCalculatedRecord::<T>::set(None);
605605
658				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)658				// stakers_number - keeps the remaining number of iterations (staker addresses to handle)
659				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out659				// next_recalc_block_for_stake - is taken from the state and stores the starting relay block from which reward should be paid out
660				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)660				// income_acc - stores the reward amount to pay to the staker address (accumulates over all address stake records)
661				while let Some((661				for ((current_id, staked_block), (amount, next_recalc_block_for_stake)) in
662					(current_id, staked_block),
663					(amount, next_recalc_block_for_stake),
664				)) = storage_iterator.next()662					storage_iterator
665				{663				{
666					// last_id is not equal current_id when we switch to handling a new staker address664					// last_id is not equal current_id when we switch to handling a new staker address
667					// or just start handling the very first address. In the latter case last_id will be None and665					// or just start handling the very first address. In the latter case last_id will be None and
859				if acc_amount < balance_per_block {857				if acc_amount < balance_per_block {
860					let res = (block, balance_per_block - acc_amount);858					let res = (block, balance_per_block - acc_amount);
861					acc_amount = <BalanceOf<T>>::default();859					acc_amount = <BalanceOf<T>>::default();
862					return Some(res);860					Some(res)
863				} else {861				} else {
864					acc_amount -= balance_per_block;862					acc_amount -= balance_per_block;
865					will_deleted_stakes_count += 1;863					will_deleted_stakes_count += 1;
866					return Some((block, <BalanceOf<T>>::default()));864					Some((block, <BalanceOf<T>>::default()))
867				}865				}
868			})866			})
869			.collect::<Vec<_>>();867			.collect::<Vec<_>>();
926		if amount.is_zero() {924		if amount.is_zero() {
927			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::thaw(925			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::thaw(
928				&T::FreezeIdentifier::get(),926				&T::FreezeIdentifier::get(),
929				&staker,927				staker,
930			)928			)
931		} else {929		} else {
932			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(930			<<T as Config>::Currency as MutateFreeze<T::AccountId>>::set_freeze(
1026	) {1024	) {
1027		let income = Self::calculate_income(base, iters);1025		let income = Self::calculate_income(base, iters);
10281026
1029		base.checked_add(&income).map(|res| {1027		if let Some(res) = base.checked_add(&income) {
1030			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));1028			<Staked<T>>::insert((staker, staked_block), (res, next_recalc_block));
1031			*income_acc += income;1029			*income_acc += income;
1032		});1030		};
1033	}1031	}
10341032
1035	fn calculate_income<I>(base: I, iters: u32) -> I1033	fn calculate_income<I>(base: I, iters: u32) -> I

149		Self {149		Self {
150			recalculation_interval: config150			recalculation_interval: config
151				.recalculation_interval151				.recalculation_interval
152				.unwrap_or_else(|| T::RecalculationInterval::get()),152				.unwrap_or_else(T::RecalculationInterval::get),
153			pending_interval: config153			pending_interval: config
154				.pending_interval154				.pending_interval
155				.unwrap_or_else(|| T::PendingInterval::get()),155				.unwrap_or_else(T::PendingInterval::get),
156			interval_income: config156			interval_income: config
157				.interval_income157				.interval_income
158				.unwrap_or_else(|| T::IntervalIncome::get()),158				.unwrap_or_else(T::IntervalIncome::get),
159			max_stakers_per_calculation: config159			max_stakers_per_calculation: config
160				.max_stakers_per_calculation160				.max_stakers_per_calculation
161				.unwrap_or_else(|| MAX_NUMBER_PAYOUTS),161				.unwrap_or(MAX_NUMBER_PAYOUTS),
162		}162		}
163	}163	}
164}164}

31	}31	}
32}32}
33
34impl<T: Config> Default for NativeFungibleHandle<T> {
35	fn default() -> Self {
36		Self::new()
37	}
38}
3339
34impl<T: Config> WithRecorder<T> for NativeFungibleHandle<T> {40impl<T: Config> WithRecorder<T> for NativeFungibleHandle<T> {
35	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {41	fn recorder(&self) -> &pallet_evm_coder_substrate::SubstrateRecorder<T> {

136136
137	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {137	fn try_from(from: up_data_structs::Property) -> Result<Self, Self::Error> {
138		let key = evm_coder::types::String::from_utf8(from.key.into())138		let key = evm_coder::types::String::from_utf8(from.key.into())
139			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {}", e)))?;139			.map_err(|e| Self::Error::Revert(format!("utf8 conversion error: {e}")))?;
140		let value = evm_coder::types::Bytes(from.value.to_vec());140		let value = evm_coder::types::Bytes(from.value.to_vec());
141		Ok(Property { key, value })141		Ok(Property { key, value })
142	}142	}
201	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {201	pub fn new(field: CollectionLimitField, value: Option<u32>) -> Self {
202		Self {202		Self {
203			field,203			field,
204			value: match value {204			value: value.map(|value| value.into()),
205				Some(value) => Some(value.into()),
206				None => None,
207			},
208		}205		}
209	}206	}
210	/// Whether the field contains a value.207	/// Whether the field contains a value.
222			.ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;219			.ok_or::<Self::Error>("can't convert `None` value to boolean".into())?;
223		let value = Some(value.try_into().map_err(|error| {220		let value = Some(value.try_into().map_err(|error| {
224			Self::Error::Revert(format!(221			Self::Error::Revert(format!(
225				"can't convert value to u32 \"{}\" because: \"{error}\"",222				"can't convert value to u32 \"{value}\" because: \"{error}\""
226				value
227			))223			))
228		})?);224		})?);
229225
249				limits.sponsored_data_size = value;245				limits.sponsored_data_size = value;
250			}246			}
251			CollectionLimitField::SponsoredDataRateLimit => {247			CollectionLimitField::SponsoredDataRateLimit => {
252				limits.sponsored_data_rate_limit = match value {248				limits.sponsored_data_rate_limit =
253					Some(value) => Some(up_data_structs::SponsoringRateLimit::Blocks(value)),249					value.map(up_data_structs::SponsoringRateLimit::Blocks);
254					None => None,
255				};
256			}250			}
257			CollectionLimitField::TokenLimit => {251			CollectionLimitField::TokenLimit => {
258				limits.token_limit = value;252				limits.token_limit = value;
454	}448	}
455}449}
456450
457impl Into<up_data_structs::AccessMode> for AccessMode {451impl From<AccessMode> for up_data_structs::AccessMode {
458	fn into(self) -> up_data_structs::AccessMode {452	fn from(value: AccessMode) -> Self {
459		match self {453		match value {
460			AccessMode::Normal => up_data_structs::AccessMode::Normal,454			AccessMode::Normal => up_data_structs::AccessMode::Normal,
461			AccessMode::AllowList => up_data_structs::AccessMode::AllowList,455			AccessMode::AllowList => up_data_structs::AccessMode::AllowList,
462		}456		}

260			message: Some(msg), ..260			message: Some(msg), ..
261		}) => ExError::Revert(msg.into()),261		}) => ExError::Revert(msg.into()),
262		DispatchError::Module(ModuleError { index, error, .. }) => {262		DispatchError::Module(ModuleError { index, error, .. }) => {
263			ExError::Revert(format!("error {:?} in pallet {}", error, index))263			ExError::Revert(format!("error {error:?} in pallet {index}"))
264		}264		}
265		e => ExError::Revert(format!("substrate error: {:?}", e)),265		e => ExError::Revert(format!("substrate error: {e:?}")),
266	}266	}
267}267}
268268

184	/// @param contractAddress The contract for which a sponsor is requested.184	/// @param contractAddress The contract for which a sponsor is requested.
185	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.185	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
186	fn sponsor(&self, contract_address: Address) -> Result<Option<eth::CrossAddress>> {186	fn sponsor(&self, contract_address: Address) -> Result<Option<eth::CrossAddress>> {
187		Ok(match Pallet::<T>::get_sponsor(contract_address) {187		Ok(Pallet::<T>::get_sponsor(contract_address)
188			Some(ref value) => Some(eth::CrossAddress::from_sub_cross_account::<T>(value)),188			.as_ref()
189			None => None,
190		})189			.map(eth::CrossAddress::from_sub_cross_account::<T>))
191	}190	}
192191
193	/// Check tat contract has confirmed sponsor.192	/// Check tat contract has confirmed sponsor.
275		self.recorder().consume_sstore()?;274		self.recorder().consume_sstore()?;
276275
277		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;276		<Pallet<T>>::ensure_owner(contract_address, caller).map_err(dispatch_to_evm::<T>)?;
278		<Pallet<T>>::set_sponsoring_fee_limit(contract_address, fee_limit.into())277		<Pallet<T>>::set_sponsoring_fee_limit(contract_address, fee_limit)
279			.map_err(dispatch_to_evm::<T>)?;278			.map_err(dispatch_to_evm::<T>)?;
280		Ok(())279		Ok(())
281	}280	}

376			<SponsoringMode<T>>::get(contract)376			<SponsoringMode<T>>::get(contract)
377				.or_else(|| {377				.or_else(|| {
378					#[allow(deprecated)]378					#[allow(deprecated)]
379					<SelfSponsoring<T>>::get(contract).then(|| SponsoringModeT::Allowlisted)379					<SelfSponsoring<T>>::get(contract).then_some(SponsoringModeT::Allowlisted)
380				})380				})
381				.unwrap_or_default()381				.unwrap_or_default()
382		}382		}
410410
411		/// Is user added to allowlist, or he is owner of specified contract411		/// Is user added to allowlist, or he is owner of specified contract
412		pub fn allowed(contract: H160, user: H160) -> bool {412		pub fn allowed(contract: H160, user: H160) -> bool {
413			<Allowlist<T>>::get(&contract, &user) || <Owner<T>>::get(&contract) == user413			<Allowlist<T>>::get(contract, user) || <Owner<T>>::get(contract) == user
414		}414		}
415415
416		/// Toggle contract allowlist access416		/// Toggle contract allowlist access
425425
426		/// Throw error if user is not allowed to reconfigure target contract426		/// Throw error if user is not allowed to reconfigure target contract
427		pub fn ensure_owner(contract: H160, user: H160) -> DispatchResult {427		pub fn ensure_owner(contract: H160, user: H160) -> DispatchResult {
428			ensure!(<Owner<T>>::get(&contract) == user, Error::<T>::NoPermission);428			ensure!(<Owner<T>>::get(contract) == user, Error::<T>::NoPermission);
429			Ok(())429			Ok(())
430		}430		}
431	}431	}

78		pub fn begin(origin: OriginFor<T>, address: H160) -> DispatchResult {78		pub fn begin(origin: OriginFor<T>, address: H160) -> DispatchResult {
79			ensure_root(origin)?;79			ensure_root(origin)?;
80			ensure!(80			ensure!(
81				<PalletEvm<T>>::is_account_empty(&address) && !<MigrationPending<T>>::get(&address),81				<PalletEvm<T>>::is_account_empty(&address) && !<MigrationPending<T>>::get(address),
82				<Error<T>>::AccountNotEmpty,82				<Error<T>>::AccountNotEmpty,
83			);83			);
8484
97		) -> DispatchResult {97		) -> DispatchResult {
98			ensure_root(origin)?;98			ensure_root(origin)?;
99			ensure!(99			ensure!(
100				<MigrationPending<T>>::get(&address),100				<MigrationPending<T>>::get(address),
101				<Error<T>>::AccountIsNotMigrating,101				<Error<T>>::AccountIsNotMigrating,
102			);102			);
103103
104			for (k, v) in data {104			for (k, v) in data {
105				<pallet_evm::AccountStorages<T>>::insert(&address, k, v);105				<pallet_evm::AccountStorages<T>>::insert(address, k, v);
106			}106			}
107			Ok(())107			Ok(())
108		}108		}
115		pub fn finish(origin: OriginFor<T>, address: H160, code: Vec<u8>) -> DispatchResult {115		pub fn finish(origin: OriginFor<T>, address: H160, code: Vec<u8>) -> DispatchResult {
116			ensure_root(origin)?;116			ensure_root(origin)?;
117			ensure!(117			ensure!(
118				<MigrationPending<T>>::get(&address),118				<MigrationPending<T>>::get(address),
119				<Error<T>>::AccountIsNotMigrating,119				<Error<T>>::AccountIsNotMigrating,
120			);120			);
121121
122			<pallet_evm::AccountCodes<T>>::insert(&address, code);122			<pallet_evm::AccountCodes<T>>::insert(address, code);
123			<MigrationPending<T>>::remove(address);123			<MigrationPending<T>>::remove(address);
124			Ok(())124			Ok(())
125		}125		}
166	pub struct OnMethodCall<T>(PhantomData<T>);166	pub struct OnMethodCall<T>(PhantomData<T>);
167	impl<T: Config> pallet_evm::OnMethodCall<T> for OnMethodCall<T> {167	impl<T: Config> pallet_evm::OnMethodCall<T> for OnMethodCall<T> {
168		fn is_reserved(contract: &H160) -> bool {168		fn is_reserved(contract: &H160) -> bool {
169			<MigrationPending<T>>::get(&contract)169			<MigrationPending<T>>::get(contract)
170		}170		}
171171
172		fn is_used(_contract: &H160) -> bool {172		fn is_used(_contract: &H160) -> bool {

333					&Value::new(0),333					&Value::new(0),
334				)?;334				)?;
335335
336				Ok(amount.into())336				Ok(amount)
337			}337			}
338		}338		}
339	}339	}

161161
162	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId> {162	fn get_currency_id(multi_location: MultiLocation) -> Option<CurrencyId> {
163		log::trace!(target: "fassets::get_currency_id", "call");163		log::trace!(target: "fassets::get_currency_id", "call");
164		Pallet::<T>::location_to_currency_ids(multi_location).map(|id| AssetIds::ForeignAssetId(id))164		Pallet::<T>::location_to_currency_ids(multi_location).map(AssetIds::ForeignAssetId)
165	}165	}
166}166}
167167
378				foreign_asset_id,378				foreign_asset_id,
379				|maybe_location| -> DispatchResult {379				|maybe_location| -> DispatchResult {
380					ensure!(maybe_location.is_none(), Error::<T>::MultiLocationExisted);380					ensure!(maybe_location.is_none(), Error::<T>::MultiLocationExisted);
381					*maybe_location = Some(location.clone());381					*maybe_location = Some(*location);
382382
383					AssetMetadatas::<T>::try_mutate(383					AssetMetadatas::<T>::try_mutate(
384						AssetIds::ForeignAssetId(foreign_asset_id),384						AssetIds::ForeignAssetId(foreign_asset_id),
422422
423						// modify location423						// modify location
424						if location != old_multi_locations {424						if location != old_multi_locations {
425							LocationToCurrencyIds::<T>::remove(old_multi_locations.clone());425							LocationToCurrencyIds::<T>::remove(*old_multi_locations);
426							LocationToCurrencyIds::<T>::try_mutate(426							LocationToCurrencyIds::<T>::try_mutate(
427								location,427								location,
428								|maybe_currency_ids| -> DispatchResult {428								|maybe_currency_ids| -> DispatchResult {
437							)?;437							)?;
438						}438						}
439						*maybe_asset_metadatas = Some(metadata.clone());439						*maybe_asset_metadatas = Some(metadata.clone());
440						*old_multi_locations = location.clone();440						*old_multi_locations = *location;
441						Ok(())441						Ok(())
442					},442					},
443				)443				)

104			Data::Raw(ref x) => {104			Data::Raw(ref x) => {
105				let l = x.len().min(32);105				let l = x.len().min(32);
106				let mut r = vec![l as u8 + 1; l + 1];106				let mut r = vec![l as u8 + 1; l + 1];
107				r[1..].copy_from_slice(&x[..l as usize]);107				r[1..].copy_from_slice(&x[..l]);
108				r108				r
109			}109			}
110			Data::BlakeTwo256(ref h) => once(34u8).chain(h.iter().cloned()).collect(),110			Data::BlakeTwo256(ref h) => once(34u8).chain(h.iter().cloned()).collect(),
287	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {287	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
288		let field = u64::decode(input)?;288		let field = u64::decode(input)?;
289		Ok(Self(289		Ok(Self(
290			<BitFlags<IdentityField>>::from_bits(field as u64).map_err(|_| "invalid value")?,290			<BitFlags<IdentityField>>::from_bits(field).map_err(|_| "invalid value")?,
291		))291		))
292	}292	}
293}293}

2121
22extern crate alloc;22extern crate alloc;
23
24use alloc::string::ToString;
23use core::{25use core::{
24	char::{REPLACEMENT_CHARACTER, decode_utf16},26	char::{REPLACEMENT_CHARACTER, decode_utf16},
25	convert::TryInto,27	convert::TryInto,
356				.transpose()358				.transpose()
357				.map_err(|e| {359				.map_err(|e| {
358					Error::Revert(alloc::format!(360					Error::Revert(alloc::format!(
359						"Can not convert value \"baseURI\" to string with error \"{}\"",361						"Can not convert value \"baseURI\" to string with error \"{e}\""
360						e
361					))362					))
362				})?;363				})?;
363364
675					.try_into()676					.try_into()
676					.map_err(|_| "token uri is too long")?,677					.map_err(|_| "token uri is too long")?,
677			})678			})
678			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;679			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {e:?}")))?;
679680
680		<Pallet<T>>::create_item(681		<Pallet<T>>::create_item(
681			self,682			self,
717		.map(Clone::clone)718		.map(Clone::clone)
718		.ok_or_else(|| {719		.ok_or_else(|| {
719			let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();720			let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();
720			Error::Revert(alloc::format!("No permission for key {}", key))721			Error::Revert(alloc::format!("No permission for key {key}"))
721		})?;722		})?;
722	Ok(a)723	Ok(a)
723}724}
752	/// @param tokenId Id for the token.753	/// @param tokenId Id for the token.
753	#[solidity(hide)]754	#[solidity(hide)]
754	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {755	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
755		Self::owner_of_cross(&self, token_id)756		Self::owner_of_cross(self, token_id)
756	}757	}
757758
758	/// Returns the owner (in cross format) of the token.759	/// Returns the owner (in cross format) of the token.
759	///760	///
760	/// @param tokenId Id for the token.761	/// @param tokenId Id for the token.
761	fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {762	fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {
762		Self::token_owner(&self, token_id.try_into()?)763		Self::token_owner(self, token_id.try_into()?)
763			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))764			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
764			.map_err(|_| Error::Revert("token not found".into()))765			.map_err(|_| Error::Revert("token not found".into()))
765	}766	}
789			.collect::<Result<Vec<_>>>()?;790			.collect::<Result<Vec<_>>>()?;
790791
791		<Self as CommonCollectionOperations<T>>::token_properties(792		<Self as CommonCollectionOperations<T>>::token_properties(
792			&self,793			self,
793			token_id.try_into()?,794			token_id.try_into()?,
794			if keys.is_empty() { None } else { Some(keys) },795			if keys.is_empty() { None } else { Some(keys) },
795		)796		)
1021						.try_into()1022						.try_into()
1022						.map_err(|_| "token uri is too long")?,1023						.map_err(|_| "token uri is too long")?,
1023				})1024				})
1024				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;1025				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {e:?}")))?;
10251026
1026			data.push(CreateItemData::<T> {1027			data.push(CreateItemData::<T> {
1027				properties,1028				properties,
1056			.map(eth::Property::try_into)1057			.map(eth::Property::try_into)
1057			.collect::<Result<Vec<_>>>()?1058			.collect::<Result<Vec<_>>>()?
1058			.try_into()1059			.try_into()
1059			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;1060			.map_err(|_| Error::Revert("too many properties".to_string()))?;
10601061
1061		let caller = T::CrossAccountId::from_eth(caller);1062		let caller = T::CrossAccountId::from_eth(caller);
10621063

863		<TokenData<T>>::insert(860		<TokenData<T>>::insert((collection.id, token), ItemData { owner: to.clone() });
864			(collection.id, token),
865			ItemData {
866				owner: to.clone(),
867				..token_data
868			},
869		);
870861
871		if let Some(balance_to) = balance_to {862		if let Some(balance_to) = balance_to {

2121
22extern crate alloc;22extern crate alloc;
2323
24use alloc::string::ToString;
24use core::{25use core::{
25	char::{REPLACEMENT_CHARACTER, decode_utf16},26	char::{REPLACEMENT_CHARACTER, decode_utf16},
26	convert::TryInto,27	convert::TryInto,
353				.transpose()354				.transpose()
354				.map_err(|e| {355				.map_err(|e| {
355					Error::Revert(alloc::format!(356					Error::Revert(alloc::format!(
356						"Can not convert value \"baseURI\" to string with error \"{}\"",357						"Can not convert value \"baseURI\" to string with error \"{e}\""
357						e
358					))358					))
359				})?;359				})?;
360360
482			.recorder482			.recorder
483			.weight_calls_budget(<StructureWeight<T>>::find_parent());483			.weight_calls_budget(<StructureWeight<T>>::find_parent());
484484
485		let balance = balance(&self, token, &from)?;485		let balance = balance(self, token, &from)?;
486		ensure_single_owner(&self, token, balance)?;486		ensure_single_owner(self, token, balance)?;
487487
488		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)488		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)
489			.map_err(dispatch_to_evm::<T>)?;489			.map_err(dispatch_to_evm::<T>)?;
575		let caller = T::CrossAccountId::from_eth(caller);575		let caller = T::CrossAccountId::from_eth(caller);
576		let token = token_id.try_into()?;576		let token = token_id.try_into()?;
577577
578		let balance = balance(&self, token, &caller)?;578		let balance = balance(self, token, &caller)?;
579		ensure_single_owner(&self, token, balance)?;579		ensure_single_owner(self, token, balance)?;
580580
581		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;581		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;
582		Ok(())582		Ok(())
622			return Err("item id should be next".into());622			return Err("item id should be next".into());
623		}623		}
624624
625		let users = [(to.clone(), 1)]625		let users = [(to, 1)]
626			.into_iter()626			.into_iter()
627			.collect::<BTreeMap<_, _>>()627			.collect::<BTreeMap<_, _>>()
628			.try_into()628			.try_into()
706					.try_into()706					.try_into()
707					.map_err(|_| "token uri is too long")?,707					.map_err(|_| "token uri is too long")?,
708			})708			})
709			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;709			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {e:?}")))?;
710710
711		let users = [(to.clone(), 1)]711		let users = [(to, 1)]
712			.into_iter()712			.into_iter()
713			.collect::<BTreeMap<_, _>>()713			.collect::<BTreeMap<_, _>>()
714			.try_into()714			.try_into()
750		.map(Clone::clone)750		.map(Clone::clone)
751		.ok_or_else(|| {751		.ok_or_else(|| {
752			let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();752			let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();
753			Error::Revert(alloc::format!("No permission for key {}", key))753			Error::Revert(alloc::format!("No permission for key {key}"))
754		})?;754		})?;
755	Ok(a)755	Ok(a)
756}756}
785	/// @param tokenId Id for the token.785	/// @param tokenId Id for the token.
786	#[solidity(hide)]786	#[solidity(hide)]
787	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {787	fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {
788		Self::owner_of_cross(&self, token_id)788		Self::owner_of_cross(self, token_id)
789	}789	}
790790
791	/// Returns the owner (in cross format) of the token.791	/// Returns the owner (in cross format) of the token.
792	///792	///
793	/// @param tokenId Id for the token.793	/// @param tokenId Id for the token.
794	fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {794	fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {
795		Self::token_owner(&self, token_id.try_into()?)795		Self::token_owner(self, token_id.try_into()?)
796			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))796			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))
797			.or_else(|err| match err {797			.or_else(|err| match err {
798				TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),798				TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),
827			.collect::<Result<Vec<_>>>()?;827			.collect::<Result<Vec<_>>>()?;
828828
829		<Self as CommonCollectionOperations<T>>::token_properties(829		<Self as CommonCollectionOperations<T>>::token_properties(
830			&self,830			self,
831			token_id.try_into()?,831			token_id.try_into()?,
832			if keys.is_empty() { None } else { Some(keys) },832			if keys.is_empty() { None } else { Some(keys) },
833		)833		)
1004			}1004			}
1005			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1005			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
1006		}1006		}
1007		let users = [(to.clone(), 1)]1007		let users = [(to, 1)]
1008			.into_iter()1008			.into_iter()
1009			.collect::<BTreeMap<_, _>>()1009			.collect::<BTreeMap<_, _>>()
1010			.try_into()1010			.try_into()
1046			.weight_calls_budget(<StructureWeight<T>>::find_parent());1046			.weight_calls_budget(<StructureWeight<T>>::find_parent());
10471047
1048		let mut data = Vec::with_capacity(tokens.len());1048		let mut data = Vec::with_capacity(tokens.len());
1049		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]1049		let users: BoundedBTreeMap<_, _, _> = [(to, 1)]
1050			.into_iter()1050			.into_iter()
1051			.collect::<BTreeMap<_, _>>()1051			.collect::<BTreeMap<_, _>>()
1052			.try_into()1052			.try_into()
1067						.try_into()1067						.try_into()
1068						.map_err(|_| "token uri is too long")?,1068						.map_err(|_| "token uri is too long")?,
1069				})1069				})
1070				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;1070				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {e:?}")))?;
10711071
1072			let create_item_data = CreateItemData::<T> {1072			let create_item_data = CreateItemData::<T> {
1073				users: users.clone(),1073				users: users.clone(),
1103			.map(eth::Property::try_into)1103			.map(eth::Property::try_into)
1104			.collect::<Result<Vec<_>>>()?1104			.collect::<Result<Vec<_>>>()?
1105			.try_into()1105			.try_into()
1106			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;1106			.map_err(|_| Error::Revert("too many properties".to_string()))?;
11071107
1108		let caller = T::CrossAccountId::from_eth(caller);1108		let caller = T::CrossAccountId::from_eth(caller);
11091109