difftreelog
Merge pull request #1007 from UniqueNetwork/fix/token-properties-benchmarks
in: master
Fix token properties and nesting weights
32 files changed
pallets/balances-adapter/src/common.rsdiffbeforeafterboth--- a/pallets/balances-adapter/src/common.rs
+++ b/pallets/balances-adapter/src/common.rs
@@ -30,15 +30,7 @@
Weight::default()
}
- fn delete_collection_properties(_amount: u32) -> Weight {
- Weight::default()
- }
-
fn set_token_properties(_amount: u32) -> Weight {
- Weight::default()
- }
-
- fn delete_token_properties(_amount: u32) -> Weight {
Weight::default()
}
@@ -63,18 +55,6 @@
}
fn burn_from() -> Weight {
- Weight::default()
- }
-
- fn burn_recursively_self_raw() -> Weight {
- Weight::default()
- }
-
- fn burn_recursively_breadth_raw(_amount: u32) -> Weight {
- Weight::default()
- }
-
- fn token_owner() -> Weight {
Weight::default()
}
@@ -124,16 +104,6 @@
_sender: <T>::CrossAccountId,
_token: TokenId,
_amount: u128,
- ) -> frame_support::pallet_prelude::DispatchResultWithPostInfo {
- fail!(<pallet_common::Error<T>>::UnsupportedOperation);
- }
-
- fn burn_item_recursively(
- &self,
- _sender: <T>::CrossAccountId,
- _token: TokenId,
- _self_budget: &dyn up_data_structs::budget::Budget,
- _breadth_budget: &dyn up_data_structs::budget::Budget,
) -> frame_support::pallet_prelude::DispatchResultWithPostInfo {
fail!(<pallet_common::Error<T>>::UnsupportedOperation);
}
pallets/common/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/common/src/benchmarking.rs
+++ b/pallets/common/src/benchmarking.rs
@@ -29,12 +29,11 @@
use sp_std::{vec, vec::Vec};
use up_data_structs::{
AccessMode, CollectionId, CollectionMode, CollectionPermissions, CreateCollectionData,
- NestingPermissions, PropertiesPermissionMap, Property, PropertyKey, PropertyValue,
- MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM,
- MAX_TOKEN_PREFIX_LENGTH,
+ NestingPermissions, Property, PropertyKey, PropertyValue, MAX_COLLECTION_DESCRIPTION_LENGTH,
+ MAX_COLLECTION_NAME_LENGTH, MAX_PROPERTIES_PER_ITEM, MAX_TOKEN_PREFIX_LENGTH,
};
-use crate::{CollectionHandle, Config, Pallet};
+use crate::{BenchmarkPropertyWriter, CollectionHandle, Config, Pallet};
const SEED: u32 = 1;
@@ -126,16 +125,6 @@
)
}
-pub fn load_is_admin_and_property_permissions<T: Config>(
- collection: &CollectionHandle<T>,
- sender: &T::CrossAccountId,
-) -> (bool, PropertiesPermissionMap) {
- (
- collection.is_owner_or_admin(sender),
- <Pallet<T>>::property_permissions(collection.id),
- )
-}
-
/// Helper macros, which handles all benchmarking preparation in semi-declarative way
///
/// `name` is a substrate account
@@ -200,31 +189,6 @@
#[block]
{
<Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
- }
-
- Ok(())
- }
-
- #[benchmark]
- fn delete_collection_properties(
- b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
- ) -> Result<(), BenchmarkError> {
- bench_init! {
- owner: sub; collection: collection(owner);
- owner: cross_from_sub;
- };
- let props = (0..b)
- .map(|p| Property {
- key: property_key(p as usize),
- value: property_value(),
- })
- .collect::<Vec<_>>();
- <Pallet<T>>::set_collection_properties(&collection, &owner, props.into_iter())?;
- let to_delete = (0..b).map(|p| property_key(p as usize)).collect::<Vec<_>>();
-
- #[block]
- {
- <Pallet<T>>::delete_collection_properties(&collection, &owner, to_delete.into_iter())?;
}
Ok(())
@@ -263,7 +227,7 @@
}
#[benchmark]
- fn init_token_properties_common() -> Result<(), BenchmarkError> {
+ fn property_writer_load_collection_info() -> Result<(), BenchmarkError> {
bench_init! {
owner: sub; collection: collection(owner);
sender: sub;
@@ -272,7 +236,7 @@
#[block]
{
- load_is_admin_and_property_permissions(&collection, &sender);
+ <BenchmarkPropertyWriter<T>>::load_collection_info(&&collection, &sender);
}
Ok(())
pallets/common/src/erc.rsdiffbeforeafterboth--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -126,7 +126,7 @@
///
/// @param key Property key.
#[solidity(hide)]
- #[weight(<SelfWeightOf<T>>::delete_collection_properties(1))]
+ #[weight(<SelfWeightOf<T>>::set_collection_properties(1))]
fn delete_collection_property(&mut self, caller: Caller, key: String) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let key = <Vec<u8>>::from(key)
@@ -139,7 +139,7 @@
/// Delete collection properties.
///
/// @param keys Properties keys.
- #[weight(<SelfWeightOf<T>>::delete_collection_properties(keys.len() as u32))]
+ #[weight(<SelfWeightOf<T>>::set_collection_properties(keys.len() as u32))]
fn delete_collection_properties(&mut self, caller: Caller, keys: Vec<String>) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let keys = keys
pallets/common/src/lib.rsdiffbeforeafterboth--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -53,10 +53,12 @@
#![cfg_attr(not(feature = "std"), no_std)]
extern crate alloc;
+use alloc::boxed::Box;
use core::{
marker::PhantomData,
ops::{Deref, DerefMut},
slice::from_ref,
+ unreachable,
};
use evm_coder::ToLog;
@@ -871,63 +873,77 @@
>;
}
+enum LazyValueState<'a, T> {
+ Pending(Box<dyn FnOnce() -> T + 'a>),
+ InProgress,
+ Computed(T),
+}
+
/// Value representation with delayed initialization time.
-pub struct LazyValue<T, F: FnOnce() -> T> {
- value: Option<T>,
- f: Option<F>,
+pub struct LazyValue<'a, T> {
+ state: LazyValueState<'a, T>,
}
-impl<T, F: FnOnce() -> T> LazyValue<T, F> {
+impl<'a, T> LazyValue<'a, T> {
/// Create a new LazyValue.
- pub fn new(f: F) -> Self {
+ pub fn new(f: impl FnOnce() -> T + 'a) -> Self {
Self {
- value: None,
- f: Some(f),
+ state: LazyValueState::Pending(Box::new(f)),
}
}
/// Get the value. If it is called the first time, the value will be initialized.
pub fn value(&mut self) -> &T {
self.force_value();
- self.value.as_ref().unwrap()
+ self.value_mut()
}
/// Get the value. If it is called the first time, the value will be initialized.
pub fn value_mut(&mut self) -> &mut T {
self.force_value();
- self.value.as_mut().unwrap()
+
+ if let LazyValueState::Computed(value) = &mut self.state {
+ value
+ } else {
+ unreachable!()
+ }
}
fn into_inner(mut self) -> T {
self.force_value();
- self.value.unwrap()
+ if let LazyValueState::Computed(value) = self.state {
+ value
+ } else {
+ unreachable!()
+ }
}
/// Is value initialized?
pub fn has_value(&self) -> bool {
- self.value.is_some()
+ matches!(self.state, LazyValueState::Computed(_))
}
fn force_value(&mut self) {
- if self.value.is_none() {
- self.value = Some(self.f.take().unwrap()())
+ use LazyValueState::*;
+
+ if self.has_value() {
+ return;
+ }
+
+ match sp_std::mem::replace(&mut self.state, InProgress) {
+ Pending(f) => self.state = Computed(f()),
+ _ => panic!("recursion isn't supported"),
}
}
}
-fn check_token_permissions<T, FCA, FTO, FTE>(
+fn check_token_permissions<T: Config>(
collection_admin_permitted: bool,
token_owner_permitted: bool,
- is_collection_admin: &mut LazyValue<bool, FCA>,
- is_token_owner: &mut LazyValue<Result<bool, DispatchError>, FTO>,
- is_token_exist: &mut LazyValue<bool, FTE>,
-) -> DispatchResult
-where
- T: Config,
- FCA: FnOnce() -> bool,
- FTO: FnOnce() -> Result<bool, DispatchError>,
- FTE: FnOnce() -> bool,
-{
+ is_collection_admin: &mut LazyValue<bool>,
+ is_token_owner: &mut LazyValue<Result<bool, DispatchError>>,
+ is_token_exist: &mut LazyValue<bool>,
+) -> DispatchResult {
if !(collection_admin_permitted && *is_collection_admin.value()
|| token_owner_permitted && (*is_token_owner.value())?)
{
@@ -1902,7 +1918,9 @@
/// Collection property deletion weight.
///
/// * `amount`- The number of properties to set.
- fn delete_collection_properties(amount: u32) -> Weight;
+ fn delete_collection_properties(amount: u32) -> Weight {
+ Self::set_collection_properties(amount)
+ }
/// Token property setting weight.
///
@@ -1912,7 +1930,9 @@
/// Token property deletion weight.
///
/// * `amount`- The number of properties to delete.
- fn delete_token_properties(amount: u32) -> Weight;
+ fn delete_token_properties(amount: u32) -> Weight {
+ Self::set_token_properties(amount)
+ }
/// Token property permissions set weight.
///
@@ -1933,31 +1953,7 @@
/// The price of burning a token from another user.
fn burn_from() -> Weight;
-
- /// Differs from burn_item in case of Fungible and Refungible, as it should burn
- /// whole users's balance.
- ///
- /// This method shouldn't be used directly, as it doesn't count breadth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead
- fn burn_recursively_self_raw() -> Weight;
- /// Cost of iterating over `amount` children while burning, without counting child burning itself.
- ///
- /// This method shouldn't be used directly, as it doesn't count depth price, use [burn_recursively](CommonWeightInfo::burn_recursively) instead
- fn burn_recursively_breadth_raw(amount: u32) -> Weight;
-
- /// The price of recursive burning a token.
- ///
- /// `max_selfs` - The maximum burning weight of the token itself.
- /// `max_breadth` - The maximum number of nested tokens to burn.
- fn burn_recursively(max_selfs: u32, max_breadth: u32) -> Weight {
- Self::burn_recursively_self_raw()
- .saturating_mul(max_selfs.max(1) as u64)
- .saturating_add(Self::burn_recursively_breadth_raw(max_breadth))
- }
-
- /// The price of retrieving token owner
- fn token_owner() -> Weight;
-
/// The price of setting approval for all
fn set_allowance_for_all() -> Weight;
@@ -2029,20 +2025,6 @@
amount: u128,
) -> DispatchResultWithPostInfo;
- /// Burn token and all nested tokens recursievly.
- ///
- /// * `sender` - The user who owns the token.
- /// * `token` - Token id that will burned.
- /// * `self_budget` - The budget that can be spent on burning tokens.
- /// * `breadth_budget` - The budget that can be spent on burning nested tokens.
- fn burn_item_recursively(
- &self,
- sender: T::CrossAccountId,
- token: TokenId,
- self_budget: &dyn Budget,
- breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo;
-
/// Set collection properties.
///
/// * `sender` - Must be either the owner of the collection or its admin.
@@ -2374,160 +2356,33 @@
}
}
-/// A marker structure that enables the writer implementation
-/// to provide the interface to write properties to **newly created** tokens.
-pub struct NewTokenPropertyWriter;
-
-/// A marker structure that enables the writer implementation
-/// to provide the interface to write properties to **already existing** tokens.
-pub struct ExistingTokenPropertyWriter;
-
/// The type-safe interface for writing properties (setting or deleting) to tokens.
/// It has two distinct implementations for newly created tokens and existing ones.
///
/// This type utilizes the lazy evaluation to avoid repeating the computation
/// of several performance-heavy or PoV-heavy tasks,
/// such as checking the indirect ownership or reading the token property permissions.
-pub struct PropertyWriter<
- 'a,
- T,
- Handle,
- WriterVariant,
- FIsAdmin,
- FPropertyPermissions,
- FCheckTokenExist,
- FGetProperties,
-> where
- T: Config,
- FIsAdmin: FnOnce() -> bool,
- FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
-{
+pub struct PropertyWriter<'a, WriterVariant, T, Handle> {
collection: &'a Handle,
- is_collection_admin: LazyValue<bool, FIsAdmin>,
- property_permissions: LazyValue<PropertiesPermissionMap, FPropertyPermissions>,
- check_token_exist: FCheckTokenExist,
- get_properties: FGetProperties,
+ collection_lazy_info: PropertyWriterLazyCollectionInfo<'a>,
_phantom: PhantomData<(T, WriterVariant)>,
}
-impl<'a, T, Handle, FIsAdmin, FPropertyPermissions, FCheckTokenExist, FGetProperties>
- PropertyWriter<
- 'a,
- T,
- Handle,
- NewTokenPropertyWriter,
- FIsAdmin,
- FPropertyPermissions,
- FCheckTokenExist,
- FGetProperties,
- > where
- T: Config,
- Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
- FIsAdmin: FnOnce() -> bool,
- FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
- FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
- FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
-{
- /// A function to write properties to a **newly created** token.
- pub fn write_token_properties(
- &mut self,
- mint_target_is_sender: bool,
- token_id: TokenId,
- properties_updates: impl Iterator<Item = Property>,
- log: evm_coder::ethereum::Log,
- ) -> DispatchResult {
- self.internal_write_token_properties(
- token_id,
- properties_updates.map(|p| (p.key, Some(p.value))),
- |_| Ok(mint_target_is_sender),
- log,
- )
- }
-}
-
-impl<'a, T, Handle, FIsAdmin, FPropertyPermissions, FCheckTokenExist, FGetProperties>
- PropertyWriter<
- 'a,
- T,
- Handle,
- ExistingTokenPropertyWriter,
- FIsAdmin,
- FPropertyPermissions,
- FCheckTokenExist,
- FGetProperties,
- > where
+impl<'a, T, Handle, WriterVariant> PropertyWriter<'a, WriterVariant, T, Handle>
+where
T: Config,
Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
- FIsAdmin: FnOnce() -> bool,
- FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
- FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
- FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
{
- /// A function to write properties to an **already existing** token.
- pub fn write_token_properties(
+ fn internal_write_token_properties(
&mut self,
- sender: &T::CrossAccountId,
token_id: TokenId,
+ mut token_lazy_info: PropertyWriterLazyTokenInfo,
properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
- nesting_budget: &dyn Budget,
log: evm_coder::ethereum::Log,
) -> DispatchResult {
- self.internal_write_token_properties(
- token_id,
- properties_updates,
- |collection| collection.check_token_indirect_owner(token_id, sender, nesting_budget),
- log,
- )
- }
-}
-
-impl<
- 'a,
- T,
- Handle,
- WriterVariant,
- FIsAdmin,
- FPropertyPermissions,
- FCheckTokenExist,
- FGetProperties,
- >
- PropertyWriter<
- 'a,
- T,
- Handle,
- WriterVariant,
- FIsAdmin,
- FPropertyPermissions,
- FCheckTokenExist,
- FGetProperties,
- > where
- T: Config,
- Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
- FIsAdmin: FnOnce() -> bool,
- FPropertyPermissions: FnOnce() -> PropertiesPermissionMap,
- FCheckTokenExist: Copy + FnOnce(TokenId) -> bool,
- FGetProperties: Copy + FnOnce(TokenId) -> TokenProperties,
-{
- fn internal_write_token_properties<FCheckTokenOwner>(
- &mut self,
- token_id: TokenId,
- properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
- check_token_owner: FCheckTokenOwner,
- log: evm_coder::ethereum::Log,
- ) -> DispatchResult
- where
- FCheckTokenOwner: FnOnce(&Handle) -> Result<bool, DispatchError>,
- {
- let get_properties = self.get_properties;
- let mut stored_properties = LazyValue::new(move || get_properties(token_id));
-
- let mut is_token_owner = LazyValue::new(|| check_token_owner(self.collection));
-
- let check_token_exist = self.check_token_exist;
- let mut is_token_exist = LazyValue::new(move || check_token_exist(token_id));
-
for (key, value) in properties_updates {
let permission = self
+ .collection_lazy_info
.property_permissions
.value()
.get(&key)
@@ -2536,7 +2391,11 @@
match permission {
PropertyPermission { mutable: false, .. }
- if stored_properties.value().get(&key).is_some() =>
+ if token_lazy_info
+ .stored_properties
+ .value()
+ .get(&key)
+ .is_some() =>
{
return Err(<Error<T>>::NoPermission.into());
}
@@ -2545,18 +2404,19 @@
collection_admin,
token_owner,
..
- } => check_token_permissions::<T, _, _, _>(
+ } => check_token_permissions::<T>(
collection_admin,
token_owner,
- &mut self.is_collection_admin,
- &mut is_token_owner,
- &mut is_token_exist,
+ &mut self.collection_lazy_info.is_collection_admin,
+ &mut token_lazy_info.is_token_owner,
+ &mut token_lazy_info.is_token_exist,
)?,
}
match value {
Some(value) => {
- stored_properties
+ token_lazy_info
+ .stored_properties
.value_mut()
.try_set(key.clone(), value)
.map_err(<Error<T>>::from)?;
@@ -2568,7 +2428,8 @@
));
}
None => {
- stored_properties
+ token_lazy_info
+ .stored_properties
.value_mut()
.remove(&key)
.map_err(<Error<T>>::from)?;
@@ -2582,142 +2443,292 @@
}
}
- let properties_changed = stored_properties.has_value();
+ let properties_changed = token_lazy_info.stored_properties.has_value();
if properties_changed {
<PalletEvm<T>>::deposit_log(log);
self.collection
- .set_token_properties_raw(token_id, stored_properties.into_inner());
+ .set_token_properties_raw(token_id, token_lazy_info.stored_properties.into_inner());
}
Ok(())
}
}
-/// Create a [`PropertyWriter`] for newly created tokens.
-pub fn property_writer_for_new_token<'a, T, Handle>(
- collection: &'a Handle,
- sender: &'a T::CrossAccountId,
-) -> PropertyWriter<
- 'a,
- T,
- Handle,
- NewTokenPropertyWriter,
- impl FnOnce() -> bool + 'a,
- impl FnOnce() -> PropertiesPermissionMap + 'a,
- impl Copy + FnOnce(TokenId) -> bool + 'a,
- impl Copy + FnOnce(TokenId) -> TokenProperties + 'a,
->
+/// A helper structure for the [`PropertyWriter`] that holds
+/// the collection-related info. The info is loaded using lazy evaluation.
+/// This info is common for any token for which we write properties.
+pub struct PropertyWriterLazyCollectionInfo<'a> {
+ is_collection_admin: LazyValue<'a, bool>,
+ property_permissions: LazyValue<'a, PropertiesPermissionMap>,
+}
+
+/// A helper structure for the [`PropertyWriter`] that holds
+/// the token-related info. The info is loaded using lazy evaluation.
+pub struct PropertyWriterLazyTokenInfo<'a> {
+ is_token_exist: LazyValue<'a, bool>,
+ is_token_owner: LazyValue<'a, Result<bool, DispatchError>>,
+ stored_properties: LazyValue<'a, TokenProperties>,
+}
+
+impl<'a> PropertyWriterLazyTokenInfo<'a> {
+ /// Create a lazy token info.
+ pub fn new(
+ check_token_exist: impl FnOnce() -> bool + 'a,
+ check_token_owner: impl FnOnce() -> Result<bool, DispatchError> + 'a,
+ get_token_properties: impl FnOnce() -> TokenProperties + 'a,
+ ) -> Self {
+ Self {
+ is_token_exist: LazyValue::new(check_token_exist),
+ is_token_owner: LazyValue::new(check_token_owner),
+ stored_properties: LazyValue::new(get_token_properties),
+ }
+ }
+}
+
+/// A marker structure that enables the writer implementation
+/// to provide the interface to write properties to **newly created** tokens.
+pub struct NewTokenPropertyWriter<T>(PhantomData<T>);
+impl<T: Config> NewTokenPropertyWriter<T> {
+ /// Creates a [`PropertyWriter`] for **newly created** tokens.
+ pub fn new<'a, Handle>(
+ collection: &'a Handle,
+ sender: &'a T::CrossAccountId,
+ ) -> PropertyWriter<'a, Self, T, Handle>
+ where
+ T: Config,
+ Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+ {
+ PropertyWriter {
+ collection,
+ collection_lazy_info: PropertyWriterLazyCollectionInfo {
+ is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
+ property_permissions: LazyValue::new(|| {
+ <Pallet<T>>::property_permissions(collection.id)
+ }),
+ },
+ _phantom: PhantomData,
+ }
+ }
+}
+
+impl<'a, T, Handle> PropertyWriter<'a, NewTokenPropertyWriter<T>, T, Handle>
where
T: Config,
Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
{
- PropertyWriter {
- collection,
- is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
- property_permissions: LazyValue::new(|| <Pallet<T>>::property_permissions(collection.id)),
- check_token_exist: |token_id| {
- debug_assert!(collection.token_exists(token_id));
+ /// A function to write properties to a **newly created** token.
+ pub fn write_token_properties(
+ &mut self,
+ mint_target_is_sender: bool,
+ token_id: TokenId,
+ properties_updates: impl Iterator<Item = Property>,
+ log: evm_coder::ethereum::Log,
+ ) -> DispatchResult {
+ let check_token_exist = || {
+ debug_assert!(self.collection.token_exists(token_id));
true
- },
- get_properties: |token_id| {
- debug_assert!(collection.get_token_properties_raw(token_id).is_none());
+ };
+
+ let check_token_owner = || Ok(mint_target_is_sender);
+
+ let get_token_properties = || {
+ debug_assert!(self.collection.get_token_properties_raw(token_id).is_none());
TokenProperties::new()
- },
- _phantom: PhantomData,
+ };
+
+ self.internal_write_token_properties(
+ token_id,
+ PropertyWriterLazyTokenInfo::new(
+ check_token_exist,
+ check_token_owner,
+ get_token_properties,
+ ),
+ properties_updates.map(|p| (p.key, Some(p.value))),
+ log,
+ )
}
}
-#[cfg(feature = "runtime-benchmarks")]
-/// Create a `PropertyWriter` with preloaded `is_collection_admin` and `property_permissions.
-/// Also:
-/// * it will return `true` for the token ownership check.
-/// * it will return empty stored properties without reading them from the storage.
-pub fn collection_info_loaded_property_writer<T, Handle>(
- collection: &Handle,
- is_collection_admin: bool,
- property_permissions: PropertiesPermissionMap,
-) -> PropertyWriter<
- T,
- Handle,
- NewTokenPropertyWriter,
- impl FnOnce() -> bool,
- impl FnOnce() -> PropertiesPermissionMap,
- impl Copy + FnOnce(TokenId) -> bool,
- impl Copy + FnOnce(TokenId) -> TokenProperties,
->
+/// A marker structure that enables the writer implementation
+/// to provide the interface to write properties to **already existing** tokens.
+pub struct ExistingTokenPropertyWriter<T>(PhantomData<T>);
+impl<T: Config> ExistingTokenPropertyWriter<T> {
+ /// Creates a [`PropertyWriter`] for **already existing** tokens.
+ pub fn new<'a, Handle>(
+ collection: &'a Handle,
+ sender: &'a T::CrossAccountId,
+ ) -> PropertyWriter<'a, Self, T, Handle>
+ where
+ Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+ {
+ PropertyWriter {
+ collection,
+ collection_lazy_info: PropertyWriterLazyCollectionInfo {
+ is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
+ property_permissions: LazyValue::new(|| {
+ <Pallet<T>>::property_permissions(collection.id)
+ }),
+ },
+ _phantom: PhantomData,
+ }
+ }
+}
+
+impl<'a, T, Handle> PropertyWriter<'a, ExistingTokenPropertyWriter<T>, T, Handle>
where
T: Config,
Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
{
- PropertyWriter {
- collection,
- is_collection_admin: LazyValue::new(move || is_collection_admin),
- property_permissions: LazyValue::new(move || property_permissions),
- check_token_exist: |_token_id| true,
- get_properties: |_token_id| TokenProperties::new(),
- _phantom: PhantomData,
+ /// A function to write properties to an **already existing** token.
+ pub fn write_token_properties(
+ &mut self,
+ sender: &T::CrossAccountId,
+ token_id: TokenId,
+ properties_updates: impl Iterator<Item = (PropertyKey, Option<PropertyValue>)>,
+ nesting_budget: &dyn Budget,
+ log: evm_coder::ethereum::Log,
+ ) -> DispatchResult {
+ let check_token_exist = || self.collection.token_exists(token_id);
+ let check_token_owner = || {
+ self.collection
+ .check_token_indirect_owner(token_id, sender, nesting_budget)
+ };
+ let get_token_properties = || {
+ self.collection
+ .get_token_properties_raw(token_id)
+ .unwrap_or_default()
+ };
+
+ self.internal_write_token_properties(
+ token_id,
+ PropertyWriterLazyTokenInfo::new(
+ check_token_exist,
+ check_token_owner,
+ get_token_properties,
+ ),
+ properties_updates,
+ log,
+ )
}
}
-/// Create a [`PropertyWriter`] for already existing tokens.
-pub fn property_writer_for_existing_token<'a, T, Handle>(
- collection: &'a Handle,
- sender: &'a T::CrossAccountId,
-) -> PropertyWriter<
- 'a,
- T,
- Handle,
- ExistingTokenPropertyWriter,
- impl FnOnce() -> bool + 'a,
- impl FnOnce() -> PropertiesPermissionMap + 'a,
- impl Copy + FnOnce(TokenId) -> bool + 'a,
- impl Copy + FnOnce(TokenId) -> TokenProperties + 'a,
->
+/// A marker structure that enables the writer implementation
+/// to benchmark the token properties writing.
+#[cfg(feature = "runtime-benchmarks")]
+pub struct BenchmarkPropertyWriter<T>(PhantomData<T>);
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<T: Config> BenchmarkPropertyWriter<T> {
+ /// Creates a [`PropertyWriter`] for benchmarking tokens properties writing.
+ pub fn new<'a, Handle>(
+ collection: &'a Handle,
+ collection_lazy_info: PropertyWriterLazyCollectionInfo<'a>,
+ ) -> PropertyWriter<'a, Self, T, Handle>
+ where
+ Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
+ {
+ PropertyWriter {
+ collection,
+ collection_lazy_info,
+ _phantom: PhantomData,
+ }
+ }
+
+ /// Load the [`PropertyWriterLazyCollectionInfo`] from the storage.
+ pub fn load_collection_info<Handle>(
+ collection_handle: &Handle,
+ sender: &T::CrossAccountId,
+ ) -> PropertyWriterLazyCollectionInfo<'static>
+ where
+ Handle: Deref<Target = CollectionHandle<T>>,
+ {
+ let is_collection_admin = collection_handle.is_owner_or_admin(sender);
+ let property_permissions = <Pallet<T>>::property_permissions(collection_handle.id);
+
+ PropertyWriterLazyCollectionInfo {
+ is_collection_admin: LazyValue::new(move || is_collection_admin),
+ property_permissions: LazyValue::new(move || property_permissions),
+ }
+ }
+
+ /// Load the [`PropertyWriterLazyTokenInfo`] with token properties from the storage.
+ pub fn load_token_properties<Handle>(
+ collection: &Handle,
+ token_id: TokenId,
+ ) -> PropertyWriterLazyTokenInfo
+ where
+ Handle: CommonCollectionOperations<T>,
+ {
+ let stored_properties = collection
+ .get_token_properties_raw(token_id)
+ .unwrap_or_default();
+
+ PropertyWriterLazyTokenInfo {
+ is_token_exist: LazyValue::new(|| true),
+ is_token_owner: LazyValue::new(|| Ok(true)),
+ stored_properties: LazyValue::new(move || stored_properties),
+ }
+ }
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<'a, T, Handle> PropertyWriter<'a, BenchmarkPropertyWriter<T>, T, Handle>
where
T: Config,
Handle: CommonCollectionOperations<T> + Deref<Target = CollectionHandle<T>>,
{
- PropertyWriter {
- collection,
- is_collection_admin: LazyValue::new(|| collection.is_owner_or_admin(sender)),
- property_permissions: LazyValue::new(|| <Pallet<T>>::property_permissions(collection.id)),
- check_token_exist: |token_id| collection.token_exists(token_id),
- get_properties: |token_id| {
- collection
- .get_token_properties_raw(token_id)
- .unwrap_or_default()
- },
- _phantom: PhantomData,
+ /// A function to benchmark the writing of token properties.
+ pub fn write_token_properties(
+ &mut self,
+ token_id: TokenId,
+ properties_updates: impl Iterator<Item = Property>,
+ log: evm_coder::ethereum::Log,
+ ) -> DispatchResult {
+ let check_token_exist = || true;
+ let check_token_owner = || Ok(true);
+ let get_token_properties = TokenProperties::new;
+
+ self.internal_write_token_properties(
+ token_id,
+ PropertyWriterLazyTokenInfo::new(
+ check_token_exist,
+ check_token_owner,
+ get_token_properties,
+ ),
+ properties_updates.map(|p| (p.key, Some(p.value))),
+ log,
+ )
}
}
-/// Computes the weight delta for newly created tokens with properties.
+/// Computes the weight of writing properties to tokens.
/// * `properties_nums` - The properties num of each created token.
-/// * `init_token_properties` - The function to obtain the weight from a token's properties num.
-pub fn init_token_properties_delta<T: Config, I: Fn(u32) -> Weight>(
+/// * `per_token_weight_weight` - The function to obtain the weight
+/// of writing properties from a token's properties num.
+pub fn write_token_properties_total_weight<T: Config, I: Fn(u32) -> Weight>(
properties_nums: impl Iterator<Item = u32>,
- init_token_properties: I,
+ per_token_weight: I,
) -> Weight {
- let mut delta = properties_nums
+ let mut weight = properties_nums
.filter_map(|properties_num| {
if properties_num > 0 {
- Some(init_token_properties(properties_num))
+ Some(per_token_weight(properties_num))
} else {
None
}
})
.fold(Weight::zero(), |a, b| a.saturating_add(b));
- // If at least once the `init_token_properties` was called,
- // it means at least one newly created token has properties.
- // Becuase of that, some common collection data also was loaded and we need to add this weight.
- // However, these common data was loaded only once which is guaranteed by the `PropertyWriter`.
- if !delta.is_zero() {
- delta = delta.saturating_add(<SelfWeightOf<T>>::init_token_properties_common())
+ if !weight.is_zero() {
+ // If we are here, it means the token properties were written at least once.
+ // Because of that, some common collection data was also loaded; we must add this weight.
+ // However, this common data was loaded only once, which is guaranteed by the `PropertyWriter`.
+
+ weight = weight.saturating_add(<SelfWeightOf<T>>::property_writer_load_collection_info());
}
- delta
+ weight
}
#[cfg(any(feature = "tests", test))]
@@ -2781,20 +2792,14 @@
/* 15*/ TestCase::new(1, 1, 1, 1, 0),
];
- pub fn check_token_permissions<T, FCA, FTO, FTE>(
+ pub fn check_token_permissions<T: Config>(
collection_admin_permitted: bool,
token_owner_permitted: bool,
- is_collection_admin: &mut LazyValue<bool, FCA>,
- check_token_ownership: &mut LazyValue<Result<bool, DispatchError>, FTO>,
- check_token_existence: &mut LazyValue<bool, FTE>,
- ) -> DispatchResult
- where
- T: Config,
- FCA: FnOnce() -> bool,
- FTO: FnOnce() -> Result<bool, DispatchError>,
- FTE: FnOnce() -> bool,
- {
- crate::check_token_permissions::<T, FCA, FTO, FTE>(
+ is_collection_admin: &mut LazyValue<bool>,
+ check_token_ownership: &mut LazyValue<Result<bool, DispatchError>>,
+ check_token_existence: &mut LazyValue<bool>,
+ ) -> DispatchResult {
+ crate::check_token_permissions::<T>(
collection_admin_permitted,
token_owner_permitted,
is_collection_admin,
pallets/common/src/weights.rsdiffbeforeafterboth--- a/pallets/common/src/weights.rs
+++ b/pallets/common/src/weights.rs
@@ -3,13 +3,13 @@
//! Autogenerated weights for pallet_common
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-09-30, STEPS: `50`, REPEAT: `400`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-10-13, STEPS: `50`, REPEAT: `80`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `bench-host`, CPU: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
+//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
// Executed Command:
-// target/production/unique-collator
+// ./target/production/unique-collator
// benchmark
// pallet
// --pallet
@@ -20,7 +20,7 @@
// *
// --template=.maintain/frame-weight-template.hbs
// --steps=50
-// --repeat=400
+// --repeat=80
// --heap-pages=4096
// --output=./pallets/common/src/weights.rs
@@ -34,116 +34,87 @@
/// Weight functions needed for pallet_common.
pub trait WeightInfo {
fn set_collection_properties(b: u32, ) -> Weight;
- fn delete_collection_properties(b: u32, ) -> Weight;
fn check_accesslist() -> Weight;
- fn init_token_properties_common() -> Weight;
+ fn property_writer_load_collection_info() -> Weight;
}
/// Weights for pallet_common using the Substrate node and recommended hardware.
pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
- /// Storage: Common CollectionProperties (r:1 w:1)
- /// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionProperties` (r:1 w:1)
+ /// Proof: `Common::CollectionProperties` (`max_values`: None, `max_size`: Some(40992), added: 43467, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
fn set_collection_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `298`
// Estimated: `44457`
- // Minimum execution time: 4_987_000 picoseconds.
- Weight::from_parts(5_119_000, 44457)
- // Standard Error: 7_609
- .saturating_add(Weight::from_parts(5_750_459, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(1_u64))
- .saturating_add(T::DbWeight::get().writes(1_u64))
- }
- /// Storage: Common CollectionProperties (r:1 w:1)
- /// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn delete_collection_properties(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `303 + b * (33030 ±0)`
- // Estimated: `44457`
- // Minimum execution time: 4_923_000 picoseconds.
- Weight::from_parts(5_074_000, 44457)
- // Standard Error: 36_651
- .saturating_add(Weight::from_parts(23_145_677, 0).saturating_mul(b.into()))
+ // Minimum execution time: 4_560_000 picoseconds.
+ Weight::from_parts(28_643_440, 44457)
+ // Standard Error: 28_941
+ .saturating_add(Weight::from_parts(18_277_422, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Common Allowlist (r:1 w:0)
- /// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
+ /// Storage: `Common::Allowlist` (r:1 w:0)
+ /// Proof: `Common::Allowlist` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
fn check_accesslist() -> Weight {
// Proof Size summary in bytes:
// Measured: `373`
// Estimated: `3535`
- // Minimum execution time: 4_271_000 picoseconds.
- Weight::from_parts(4_461_000, 3535)
+ // Minimum execution time: 4_290_000 picoseconds.
+ Weight::from_parts(4_460_000, 3535)
.saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Common IsAdmin (r:1 w:0)
- /// Proof: Common IsAdmin (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- fn init_token_properties_common() -> Weight {
+ /// Storage: `Common::IsAdmin` (r:1 w:0)
+ /// Proof: `Common::IsAdmin` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:0)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
+ fn property_writer_load_collection_info() -> Weight {
// Proof Size summary in bytes:
// Measured: `326`
// Estimated: `20191`
- // Minimum execution time: 5_889_000 picoseconds.
- Weight::from_parts(6_138_000, 20191)
+ // Minimum execution time: 6_100_000 picoseconds.
+ Weight::from_parts(6_350_000, 20191)
.saturating_add(T::DbWeight::get().reads(2_u64))
}
}
// For backwards compatibility and tests
impl WeightInfo for () {
- /// Storage: Common CollectionProperties (r:1 w:1)
- /// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionProperties` (r:1 w:1)
+ /// Proof: `Common::CollectionProperties` (`max_values`: None, `max_size`: Some(40992), added: 43467, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
fn set_collection_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `298`
// Estimated: `44457`
- // Minimum execution time: 4_987_000 picoseconds.
- Weight::from_parts(5_119_000, 44457)
- // Standard Error: 7_609
- .saturating_add(Weight::from_parts(5_750_459, 0).saturating_mul(b.into()))
+ // Minimum execution time: 4_560_000 picoseconds.
+ Weight::from_parts(28_643_440, 44457)
+ // Standard Error: 28_941
+ .saturating_add(Weight::from_parts(18_277_422, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionProperties (r:1 w:1)
- /// Proof: Common CollectionProperties (max_values: None, max_size: Some(40992), added: 43467, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn delete_collection_properties(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `303 + b * (33030 ±0)`
- // Estimated: `44457`
- // Minimum execution time: 4_923_000 picoseconds.
- Weight::from_parts(5_074_000, 44457)
- // Standard Error: 36_651
- .saturating_add(Weight::from_parts(23_145_677, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(1_u64))
- .saturating_add(RocksDbWeight::get().writes(1_u64))
- }
- /// Storage: Common Allowlist (r:1 w:0)
- /// Proof: Common Allowlist (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
+ /// Storage: `Common::Allowlist` (r:1 w:0)
+ /// Proof: `Common::Allowlist` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
fn check_accesslist() -> Weight {
// Proof Size summary in bytes:
// Measured: `373`
// Estimated: `3535`
- // Minimum execution time: 4_271_000 picoseconds.
- Weight::from_parts(4_461_000, 3535)
+ // Minimum execution time: 4_290_000 picoseconds.
+ Weight::from_parts(4_460_000, 3535)
.saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Common IsAdmin (r:1 w:0)
- /// Proof: Common IsAdmin (max_values: None, max_size: Some(70), added: 2545, mode: MaxEncodedLen)
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- fn init_token_properties_common() -> Weight {
+ /// Storage: `Common::IsAdmin` (r:1 w:0)
+ /// Proof: `Common::IsAdmin` (`max_values`: None, `max_size`: Some(70), added: 2545, mode: `MaxEncodedLen`)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:0)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
+ fn property_writer_load_collection_info() -> Weight {
// Proof Size summary in bytes:
// Measured: `326`
// Estimated: `20191`
- // Minimum execution time: 5_889_000 picoseconds.
- Weight::from_parts(6_138_000, 20191)
+ // Minimum execution time: 6_100_000 picoseconds.
+ Weight::from_parts(6_350_000, 20191)
.saturating_add(RocksDbWeight::get().reads(2_u64))
}
}
pallets/evm-coder-substrate/src/lib.rsdiffbeforeafterboth--- a/pallets/evm-coder-substrate/src/lib.rs
+++ b/pallets/evm-coder-substrate/src/lib.rs
@@ -84,7 +84,7 @@
}
impl<T: Config> budget::Budget for GasCallsBudget<'_, T> {
fn consume_custom(&self, calls: u32) -> bool {
- let (gas, overflown) = (calls as u64).overflowing_add(self.gas_per_call);
+ let (gas, overflown) = (calls as u64).overflowing_mul(self.gas_per_call);
if overflown {
return false;
}
pallets/foreign-assets/src/impl_fungibles.rsdiffbeforeafterboth--- a/pallets/foreign-assets/src/impl_fungibles.rs
+++ b/pallets/foreign-assets/src/impl_fungibles.rs
@@ -23,7 +23,7 @@
use pallet_common::{CollectionHandle, CommonCollectionOperations};
use pallet_fungible::FungibleHandle;
use sp_runtime::traits::{CheckedAdd, CheckedSub};
-use up_data_structs::budget::Value;
+use up_data_structs::budget;
use super::*;
@@ -327,7 +327,7 @@
&collection,
&account,
amount_data,
- &Value::new(0),
+ &budget::Value::new(0),
)?;
Ok(amount)
@@ -440,7 +440,7 @@
&T::CrossAccountId::from_sub(source.clone()),
&T::CrossAccountId::from_sub(dest.clone()),
amount.into(),
- &Value::new(0),
+ &budget::Value::new(0),
)
.map_err(|e| e.error)?;
pallets/fungible/src/common.rsdiffbeforeafterboth--- a/pallets/fungible/src/common.rs
+++ b/pallets/fungible/src/common.rs
@@ -16,14 +16,11 @@
use core::marker::PhantomData;
-use frame_support::{
- dispatch::DispatchResultWithPostInfo, ensure, fail, traits::Get, weights::Weight,
-};
+use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
use pallet_common::{
weights::WeightInfo as _, with_weight, CommonCollectionOperations, CommonWeightInfo,
RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf,
};
-use pallet_structure::Error as StructureError;
use sp_runtime::{ArithmeticError, DispatchError};
use sp_std::{vec, vec::Vec};
use up_data_structs::{
@@ -58,18 +55,9 @@
fn set_collection_properties(amount: u32) -> Weight {
<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
- }
-
- fn delete_collection_properties(amount: u32) -> Weight {
- <pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
}
fn set_token_properties(_amount: u32) -> Weight {
- // Error
- Weight::zero()
- }
-
- fn delete_token_properties(_amount: u32) -> Weight {
// Error
Weight::zero()
}
@@ -80,7 +68,8 @@
}
fn transfer() -> Weight {
- <SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 2
+ <SelfWeightOf<T>>::transfer_raw()
+ .saturating_add(<PalletCommonWeightOf<T>>::check_accesslist().saturating_mul(2))
}
fn approve() -> Weight {
@@ -93,28 +82,14 @@
fn transfer_from() -> Weight {
Self::transfer()
- + <SelfWeightOf<T>>::check_allowed_raw()
- + <SelfWeightOf<T>>::set_allowance_unchecked_raw()
+ .saturating_add(<SelfWeightOf<T>>::check_allowed_raw())
+ .saturating_add(<SelfWeightOf<T>>::set_allowance_unchecked_raw())
}
fn burn_from() -> Weight {
<SelfWeightOf<T>>::burn_from()
}
- fn burn_recursively_self_raw() -> Weight {
- // Read to get total balance
- Self::burn_item() + T::DbWeight::get().reads(1)
- }
-
- fn burn_recursively_breadth_raw(_amount: u32) -> Weight {
- // Fungible tokens can't have children
- Weight::zero()
- }
-
- fn token_owner() -> Weight {
- Weight::zero()
- }
-
fn set_allowance_for_all() -> Weight {
Weight::zero()
}
@@ -200,26 +175,6 @@
with_weight(
<Pallet<T>>::burn(self, &sender, amount),
<CommonWeights<T>>::burn_item(),
- )
- }
-
- fn burn_item_recursively(
- &self,
- sender: T::CrossAccountId,
- token: TokenId,
- self_budget: &dyn Budget,
- _breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo {
- // Should not happen?
- ensure!(
- token == TokenId::default(),
- <Error<T>>::FungibleItemsHaveNoId
- );
- ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);
-
- with_weight(
- <Pallet<T>>::burn(self, &sender, <Balance<T>>::get((self.id, &sender))),
- <CommonWeights<T>>::burn_recursively_self_raw(),
)
}
pallets/fungible/src/erc.rsdiffbeforeafterboth--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -32,12 +32,12 @@
use pallet_evm_coder_substrate::{
call, dispatch_to_evm,
execution::{PreDispatch, Result},
- frontier_contract,
+ frontier_contract, SubstrateRecorder,
};
use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
use sp_core::{Get, U256};
use sp_std::vec::Vec;
-use up_data_structs::CollectionMode;
+use up_data_structs::{budget::Budget, CollectionMode};
use crate::{
common::CommonWeights, weights::WeightInfo, Allowance, Balance, Config, FungibleHandle, Pallet,
@@ -73,6 +73,10 @@
amount: U256,
}
+fn nesting_budget<T: Config>(recorder: &SubstrateRecorder<T>) -> impl Budget + '_ {
+ recorder.weight_calls_budget(<StructureWeight<T>>::find_parent())
+}
+
#[solidity_interface(name = ERC20, events(ERC20Events), enum(derive(PreDispatch)), enum_attr(weight), expect_selector = 0x942e8b22)]
impl<T: Config> FungibleHandle<T> {
fn name(&self) -> Result<String> {
@@ -106,11 +110,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, amount, &budget)
+ <Pallet<T>>::transfer(self, &caller, &to, amount, &nesting_budget(&self.recorder))
.map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(true)
}
@@ -127,12 +128,16 @@
let from = T::CrossAccountId::from_eth(from);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
- .map_err(|e| dispatch_to_evm::<T>(e.error))?;
+ <Pallet<T>>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(true)
}
#[weight(<SelfWeightOf<T>>::approve())]
@@ -164,10 +169,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::create_item(self, &caller, (to, amount), &budget)
+
+ <Pallet<T>>::create_item(self, &caller, (to, amount), &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -201,10 +204,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::create_item(self, &caller, (to, amount), &budget)
+
+ <Pallet<T>>::create_item(self, &caller, (to, amount), &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -236,12 +237,15 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::burn_from(
+ self,
+ &caller,
+ &from,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -260,12 +264,15 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::burn_from(
+ self,
+ &caller,
+ &from,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -274,9 +281,6 @@
#[weight(<SelfWeightOf<T>>::create_multiple_items_ex(amounts.len() as u32))]
fn mint_bulk(&mut self, caller: Caller, amounts: Vec<AmountForAddress>) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
let amounts = amounts
.into_iter()
.map(|AmountForAddress { to, amount }| {
@@ -287,7 +291,7 @@
})
.collect::<Result<_>>()?;
- <Pallet<T>>::create_multiple_items(self, &caller, amounts, &budget)
+ <Pallet<T>>::create_multiple_items(self, &caller, amounts, &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -297,11 +301,9 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, amount, &budget).map_err(|_| "transfer error")?;
+ <Pallet<T>>::transfer(self, &caller, &to, amount, &nesting_budget(&self.recorder))
+ .map_err(|_| "transfer error")?;
Ok(true)
}
@@ -317,12 +319,16 @@
let from = from.into_sub_cross_account::<T>()?;
let to = to.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer_from(self, &caller, &from, &to, amount, &budget)
- .map_err(|e| dispatch_to_evm::<T>(e.error))?;
+ <Pallet<T>>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(true)
}
pallets/nonfungible/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/benchmarking.rs
+++ b/pallets/nonfungible/src/benchmarking.rs
@@ -18,7 +18,6 @@
use pallet_common::{
bench_init,
benchmarking::{create_collection_raw, property_key, property_value},
- CommonCollectionOperations,
};
use sp_std::prelude::*;
use up_data_structs::{
@@ -131,49 +130,8 @@
#[block]
{
<Pallet<T>>::burn(&collection, &burner, item)?;
- }
-
- Ok(())
- }
-
- #[benchmark]
- fn burn_recursively_self_raw() -> Result<(), BenchmarkError> {
- bench_init! {
- owner: sub; collection: collection(owner);
- sender: cross_from_sub(owner); burner: cross_sub;
- };
- let item = create_max_item(&collection, &sender, burner.clone())?;
-
- #[block]
- {
- <Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
- }
-
- Ok(())
- }
-
- #[benchmark]
- fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(
- b: Linear<0, 200>,
- ) -> Result<(), BenchmarkError> {
- bench_init! {
- owner: sub; collection: collection(owner);
- sender: cross_from_sub(owner); burner: cross_sub;
- };
- let item = create_max_item(&collection, &sender, burner.clone())?;
- for _ in 0..b {
- create_max_item(
- &collection,
- &sender,
- T::CrossTokenAddressMapping::token_to_address(collection.id, item),
- )?;
}
- #[block]
- {
- <Pallet<T>>::burn_recursively(&collection, &burner, item, &Unlimited, &Unlimited)?;
- }
-
Ok(())
}
@@ -267,38 +225,29 @@
}
#[benchmark]
- fn set_token_property_permissions(
- b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
- ) -> Result<(), BenchmarkError> {
+ fn load_token_properties() -> Result<(), BenchmarkError> {
bench_init! {
owner: sub; collection: collection(owner);
owner: cross_from_sub;
};
- let perms = (0..b)
- .map(|k| PropertyKeyPermission {
- key: property_key(k as usize),
- permission: PropertyPermission {
- mutable: false,
- collection_admin: false,
- token_owner: false,
- },
- })
- .collect::<Vec<_>>();
+ let item = create_max_item(&collection, &owner, owner.clone())?;
+
#[block]
{
- <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+ pallet_common::BenchmarkPropertyWriter::<T>::load_token_properties(&collection, item);
}
Ok(())
}
#[benchmark]
- fn set_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
+ fn write_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
bench_init! {
owner: sub; collection: collection(owner);
owner: cross_from_sub;
};
+
let perms = (0..b)
.map(|k| PropertyKeyPermission {
key: property_key(k as usize),
@@ -318,71 +267,29 @@
.collect::<Vec<_>>();
let item = create_max_item(&collection, &owner, owner.clone())?;
+ let lazy_collection_info =
+ pallet_common::BenchmarkPropertyWriter::<T>::load_collection_info(&collection, &owner);
+
#[block]
{
- <Pallet<T>>::set_token_properties(
- &collection,
- &owner,
+ let mut property_writer =
+ pallet_common::BenchmarkPropertyWriter::new(&collection, lazy_collection_info);
+
+ property_writer.write_token_properties(
item,
props.into_iter(),
- &Unlimited,
+ crate::erc::ERC721TokenEvent::TokenChanged {
+ token_id: item.into(),
+ }
+ .to_log(T::ContractAddress::get()),
)?;
}
Ok(())
}
- // TODO:
#[benchmark]
- fn init_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
- // bench_init! {
- // owner: sub; collection: collection(owner);
- // owner: cross_from_sub;
- // };
-
- // let perms = (0..b)
- // .map(|k| PropertyKeyPermission {
- // key: property_key(k as usize),
- // permission: PropertyPermission {
- // mutable: false,
- // collection_admin: true,
- // token_owner: true,
- // },
- // })
- // .collect::<Vec<_>>();
- // <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
- #[block]
- {}
- // let props = (0..b)
- // .map(|k| Property {
- // key: property_key(k as usize),
- // value: property_value(),
- // })
- // .collect::<Vec<_>>();
- // let item = create_max_item(&collection, &owner, owner.clone())?;
-
- // let (is_collection_admin, property_permissions) =
- // load_is_admin_and_property_permissions(&collection, &owner);
- // #[block]
- // {
- // let mut property_writer =
- // pallet_common::BenchmarkPropertyWriter::new(&collection, lazy_collection_info);
-
- // property_writer.write_token_properties(
- // item,
- // props.into_iter(),
- // crate::erc::ERC721TokenEvent::TokenChanged {
- // token_id: item.into(),
- // }
- // .to_log(T::ContractAddress::get()),
- // )?;
- // }
-
- Ok(())
- }
-
- #[benchmark]
- fn delete_token_properties(
+ fn set_token_property_permissions(
b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
) -> Result<(), BenchmarkError> {
bench_init! {
@@ -393,54 +300,16 @@
.map(|k| PropertyKeyPermission {
key: property_key(k as usize),
permission: PropertyPermission {
- mutable: true,
- collection_admin: true,
- token_owner: true,
+ mutable: false,
+ collection_admin: false,
+ token_owner: false,
},
})
.collect::<Vec<_>>();
- <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
- let props = (0..b)
- .map(|k| Property {
- key: property_key(k as usize),
- value: property_value(),
- })
- .collect::<Vec<_>>();
- let item = create_max_item(&collection, &owner, owner.clone())?;
- <Pallet<T>>::set_token_properties(
- &collection,
- &owner,
- item,
- props.into_iter(),
- &Unlimited,
- )?;
- let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
#[block]
{
- <Pallet<T>>::delete_token_properties(
- &collection,
- &owner,
- item,
- to_delete.into_iter(),
- &Unlimited,
- )?;
- }
-
- Ok(())
- }
-
- #[benchmark]
- fn token_owner() -> Result<(), BenchmarkError> {
- bench_init! {
- owner: sub; collection: collection(owner);
- owner: cross_from_sub;
- };
- let item = create_max_item(&collection, &owner, owner.clone())?;
-
- #[block]
- {
- collection.token_owner(item).unwrap();
+ <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
}
Ok(())
pallets/nonfungible/src/common.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/common.rs
+++ b/pallets/nonfungible/src/common.rs
@@ -18,8 +18,9 @@
use frame_support::{dispatch::DispatchResultWithPostInfo, ensure, fail, weights::Weight};
use pallet_common::{
- init_token_properties_delta, weights::WeightInfo as _, with_weight, CommonCollectionOperations,
- CommonWeightInfo, RefungibleExtensions, SelfWeightOf as PalletCommonWeightOf,
+ weights::WeightInfo as _, with_weight, write_token_properties_total_weight,
+ CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions,
+ SelfWeightOf as PalletCommonWeightOf,
};
use pallet_structure::Pallet as PalletStructure;
use sp_runtime::DispatchError;
@@ -38,24 +39,21 @@
impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {
fn create_multiple_items_ex(data: &CreateItemExData<T::CrossAccountId>) -> Weight {
match data {
- CreateItemExData::NFT(t) => <SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32)
- .saturating_add(init_token_properties_delta::<T, _>(
- t.iter().map(|t| t.properties.len() as u32),
- <SelfWeightOf<T>>::init_token_properties,
- )),
+ CreateItemExData::NFT(t) => mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items_ex(t.len() as u32),
+ t.iter().map(|t| t.properties.len() as u32),
+ ),
_ => Weight::zero(),
}
}
fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {
- <SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(
- init_token_properties_delta::<T, _>(
- data.iter().map(|t| match t {
- up_data_structs::CreateItemData::NFT(n) => n.properties.len() as u32,
- _ => 0,
- }),
- <SelfWeightOf<T>>::init_token_properties,
- ),
+ mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items(data.len() as u32),
+ data.iter().map(|t| match t {
+ up_data_structs::CreateItemData::NFT(n) => n.properties.len() as u32,
+ _ => 0,
+ }),
)
}
@@ -65,18 +63,17 @@
fn set_collection_properties(amount: u32) -> Weight {
<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
- }
-
- fn delete_collection_properties(amount: u32) -> Weight {
- <pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
}
fn set_token_properties(amount: u32) -> Weight {
- <SelfWeightOf<T>>::set_token_properties(amount)
+ write_token_properties_total_weight::<T, _>([amount].into_iter(), |amount| {
+ <SelfWeightOf<T>>::load_token_properties()
+ .saturating_add(<SelfWeightOf<T>>::write_token_properties(amount))
+ })
}
fn delete_token_properties(amount: u32) -> Weight {
- <SelfWeightOf<T>>::delete_token_properties(amount)
+ Self::set_token_properties(amount)
}
fn set_token_property_permissions(amount: u32) -> Weight {
@@ -84,7 +81,8 @@
}
fn transfer() -> Weight {
- <SelfWeightOf<T>>::transfer_raw() + <PalletCommonWeightOf<T>>::check_accesslist() * 2
+ <SelfWeightOf<T>>::transfer_raw()
+ .saturating_add(<PalletCommonWeightOf<T>>::check_accesslist().saturating_mul(2))
}
fn approve() -> Weight {
@@ -96,24 +94,11 @@
}
fn transfer_from() -> Weight {
- Self::transfer() + <SelfWeightOf<T>>::check_allowed_raw()
+ Self::transfer().saturating_add(<SelfWeightOf<T>>::check_allowed_raw())
}
fn burn_from() -> Weight {
<SelfWeightOf<T>>::burn_from()
- }
-
- fn burn_recursively_self_raw() -> Weight {
- <SelfWeightOf<T>>::burn_recursively_self_raw()
- }
-
- fn burn_recursively_breadth_raw(amount: u32) -> Weight {
- <SelfWeightOf<T>>::burn_recursively_breadth_plus_self_plus_self_per_each_raw(amount)
- .saturating_sub(Self::burn_recursively_self_raw().saturating_mul(amount as u64 + 1))
- }
-
- fn token_owner() -> Weight {
- <SelfWeightOf<T>>::token_owner()
}
fn set_allowance_for_all() -> Weight {
@@ -125,6 +110,20 @@
}
}
+/// Weight of minting tokens with properties
+/// * `create_no_data_weight` -- the weight of minting without properties
+/// * `token_properties_nums` -- number of properties of each token
+#[inline]
+pub(crate) fn mint_with_props_weight<T: Config>(
+ create_no_data_weight: Weight,
+ token_properties_nums: impl Iterator<Item = u32> + Clone,
+) -> Weight {
+ create_no_data_weight.saturating_add(write_token_properties_total_weight::<T, _>(
+ token_properties_nums,
+ <SelfWeightOf<T>>::write_token_properties,
+ ))
+}
+
fn map_create_data<T: Config>(
data: up_data_structs::CreateItemData,
to: &T::CrossAccountId,
@@ -306,16 +305,6 @@
<Pallet<T>>::check_token_immediate_ownership(self, token, &sender)?;
Ok(().into())
}
- }
-
- fn burn_item_recursively(
- &self,
- sender: T::CrossAccountId,
- token: TokenId,
- self_budget: &dyn Budget,
- breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo {
- <Pallet<T>>::burn_recursively(self, &sender, token, self_budget, breadth_budget)
}
fn transfer(
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -38,19 +38,21 @@
use pallet_evm_coder_substrate::{
call, dispatch_to_evm,
execution::{Error, PreDispatch, Result},
- frontier_contract,
+ frontier_contract, SubstrateRecorder,
};
use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
use sp_core::{Get, U256};
use sp_std::{vec, vec::Vec};
use up_data_structs::{
- CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,
- PropertyPermission, TokenId,
+ budget::Budget, CollectionId, CollectionPropertiesVec, Property, PropertyKey,
+ PropertyKeyPermission, PropertyPermission, TokenId,
};
use crate::{
- common::CommonWeights, weights::WeightInfo, AccountBalance, Config, CreateItemData,
- NonfungibleHandle, Pallet, SelfWeightOf, TokenData, TokenProperties, TokensMinted,
+ common::{mint_with_props_weight, CommonWeights},
+ weights::WeightInfo,
+ AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, SelfWeightOf, TokenData,
+ TokenProperties, TokensMinted,
};
/// Nft events.
@@ -78,6 +80,10 @@
impl<T: Config> Contract for NonfungibleHandle<T> {...}
}
+fn nesting_budget<T: Config>(recorder: &SubstrateRecorder<T>) -> impl Budget + '_ {
+ recorder.weight_calls_budget(<StructureWeight<T>>::find_parent())
+}
+
/// @title A contract that allows to set and delete token properties and change token property permissions.
#[solidity_interface(name = TokenProperties, events(ERC721TokenEvent), enum(derive(PreDispatch)), enum_attr(weight))]
impl<T: Config> NonfungibleHandle<T> {
@@ -146,7 +152,7 @@
/// @param key Property key.
/// @param value Property value.
#[solidity(hide)]
- #[weight(<SelfWeightOf<T>>::set_token_properties(1))]
+ #[weight(<CommonWeights<T>>::set_token_properties(1))]
fn set_property(
&mut self,
caller: Caller,
@@ -161,16 +167,12 @@
.map_err(|_| "key too long")?;
let value = value.0.try_into().map_err(|_| "value too long")?;
- let nesting_budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
-
<Pallet<T>>::set_token_property(
self,
&caller,
TokenId(token_id),
Property { key, value },
- &nesting_budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)
}
@@ -179,7 +181,7 @@
/// @dev Throws error if `msg.sender` has no permission to edit the property.
/// @param tokenId ID of the token.
/// @param properties settable properties
- #[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
+ #[weight(<CommonWeights<T>>::set_token_properties(properties.len() as u32))]
fn set_properties(
&mut self,
caller: Caller,
@@ -189,10 +191,6 @@
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
- let nesting_budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
-
let properties = properties
.into_iter()
.map(eth::Property::try_into)
@@ -203,7 +201,7 @@
&caller,
TokenId(token_id),
properties.into_iter(),
- &nesting_budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)
}
@@ -213,7 +211,7 @@
/// @param tokenId ID of the token.
/// @param key Property key.
#[solidity(hide)]
- #[weight(<SelfWeightOf<T>>::delete_token_properties(1))]
+ #[weight(<CommonWeights<T>>::delete_token_properties(1))]
fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
@@ -221,19 +219,21 @@
.try_into()
.map_err(|_| "key too long")?;
- let nesting_budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
-
- <Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)
- .map_err(dispatch_to_evm::<T>)
+ <Pallet<T>>::delete_token_property(
+ self,
+ &caller,
+ TokenId(token_id),
+ key,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)
}
/// @notice Delete token properties value.
/// @dev Throws error if `msg.sender` has no permission to edit the property.
/// @param tokenId ID of the token.
/// @param keys Properties key.
- #[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]
+ #[weight(<CommonWeights<T>>::delete_token_properties(keys.len() as u32))]
fn delete_properties(
&mut self,
token_id: U256,
@@ -247,16 +247,12 @@
.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))
.collect::<Result<Vec<_>>>()?;
- let nesting_budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
-
<Pallet<T>>::delete_token_properties(
self,
&caller,
TokenId(token_id),
keys.into_iter(),
- &nesting_budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)
}
@@ -481,12 +477,16 @@
let from = T::CrossAccountId::from_eth(from);
let to = T::CrossAccountId::from_eth(to);
let token = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)
- .map_err(|e| dispatch_to_evm::<T>(e.error))?;
+ <Pallet<T>>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ token,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(())
}
@@ -594,9 +594,6 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token_id: u32 = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
if <TokensMinted<T>>::get(self.id)
.checked_add(1)
@@ -613,7 +610,7 @@
properties: BoundedVec::default(),
owner: to,
},
- &budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)?;
@@ -625,7 +622,7 @@
/// @param tokenUri Token URI that would be stored in the NFT properties
/// @return uint256 The id of the newly minted token
#[solidity(rename_selector = "mintWithTokenURI")]
- #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]
+ #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]
fn mint_with_token_uri(
&mut self,
caller: Caller,
@@ -647,7 +644,7 @@
/// @param tokenId ID of the minted NFT
/// @param tokenUri Token URI that would be stored in the NFT properties
#[solidity(hide, rename_selector = "mintWithTokenURI")]
- #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]
+ #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]
fn mint_with_token_uri_check_id(
&mut self,
caller: Caller,
@@ -664,9 +661,6 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
if <TokensMinted<T>>::get(self.id)
.checked_add(1)
@@ -694,7 +688,7 @@
properties,
owner: to,
},
- &budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
@@ -840,11 +834,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let token = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, token, &budget)
+ <Pallet<T>>::transfer(self, &caller, &to, token, &nesting_budget(&self.recorder))
.map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(())
}
@@ -864,11 +855,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, token, &budget)
+ <Pallet<T>>::transfer(self, &caller, &to, token, &nesting_budget(&self.recorder))
.map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(())
}
@@ -891,11 +879,16 @@
let from = from.into_sub_cross_account::<T>()?;
let to = to.into_sub_cross_account::<T>()?;
let token_id = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)
- .map_err(|e| dispatch_to_evm::<T>(e.error))?;
+
+ Pallet::<T>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ token_id,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(|e| dispatch_to_evm::<T>(e.error))?;
Ok(())
}
@@ -911,11 +904,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let token = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, token, &budget)
+ <Pallet<T>>::burn_from(self, &caller, &from, token, &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(())
}
@@ -936,11 +926,8 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let token = token_id.try_into()?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, token, &budget)
+ <Pallet<T>>::burn_from(self, &caller, &from, token, &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(())
}
@@ -966,9 +953,6 @@
let mut expected_index = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
let total_tokens = token_ids.len();
for id in token_ids.into_iter() {
@@ -985,19 +969,21 @@
})
.collect();
- <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
+ <Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
/// @notice Function to mint a token.
/// @param data Array of pairs of token owner and token's properties for minted token
- #[weight(<SelfWeightOf<T>>::create_multiple_items(data.len() as u32) + <SelfWeightOf<T>>::set_token_properties(data.len() as u32))]
+ #[weight(
+ mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items_ex(data.len() as u32),
+ data.iter().map(|d| d.properties.len() as u32),
+ )
+ )]
fn mint_bulk_cross(&mut self, caller: Caller, data: Vec<MintTokenData>) -> Result<bool> {
let caller = T::CrossAccountId::from_eth(caller);
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
let mut create_nft_data = Vec::with_capacity(data.len());
for MintTokenData { owner, properties } in data {
@@ -1013,8 +999,13 @@
});
}
- <Pallet<T>>::create_multiple_items(self, &caller, create_nft_data, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::create_multiple_items(
+ self,
+ &caller,
+ create_nft_data,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -1024,7 +1015,12 @@
/// @param to The new owner
/// @param tokens array of pairs of token ID and token URI for minted tokens
#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]
- #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32) + <SelfWeightOf<T>>::set_token_properties(tokens.len() as u32))]
+ #[weight(
+ mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32),
+ tokens.iter().map(|_| 1),
+ )
+ )]
fn mint_bulk_with_token_uri(
&mut self,
caller: Caller,
@@ -1037,9 +1033,6 @@
let mut expected_index = <TokensMinted<T>>::get(self.id)
.checked_add(1)
.ok_or("item id overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
let mut data = Vec::with_capacity(tokens.len());
for TokenUri { id, uri } in tokens {
@@ -1066,7 +1059,7 @@
});
}
- <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
+ <Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))
.map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -1075,7 +1068,7 @@
/// @param to The new owner crossAccountId
/// @param properties Properties of minted token
/// @return uint256 The id of the newly minted token
- #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]
+ #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [properties.len() as u32].into_iter()))]
fn mint_cross(
&mut self,
caller: Caller,
@@ -1096,10 +1089,6 @@
.map_err(|_| Error::Revert("too many properties".to_string()))?;
let caller = T::CrossAccountId::from_eth(caller);
-
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
<Pallet<T>>::create_item(
self,
@@ -1108,7 +1097,7 @@
properties,
owner: to,
},
- &budget,
+ &nesting_budget(&self.recorder),
)
.map_err(dispatch_to_evm::<T>)?;
pallets/nonfungible/src/lib.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -109,7 +109,7 @@
};
use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
use pallet_evm_coder_substrate::{SubstrateRecorder, WithRecorder};
-use pallet_structure::{Error as StructureError, Pallet as PalletStructure};
+use pallet_structure::Pallet as PalletStructure;
use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
use scale_info::TypeInfo;
use sp_core::{Get, H160};
@@ -502,52 +502,7 @@
));
Ok(())
}
-
- /// Same as [`burn`] but burns all the tokens that are nested in the token first
- ///
- /// - `self_budget`: Limit for searching children in depth.
- /// - `breadth_budget`: Limit of breadth of searching children.
- ///
- /// [`burn`]: struct.Pallet.html#method.burn
- #[transactional]
- pub fn burn_recursively(
- collection: &NonfungibleHandle<T>,
- sender: &T::CrossAccountId,
- token: TokenId,
- self_budget: &dyn Budget,
- breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo {
- ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);
- let current_token_account =
- T::CrossTokenAddressMapping::token_to_address(collection.id, token);
-
- let mut weight = Weight::zero();
-
- // This method is transactional, if user in fact doesn't have permissions to remove token -
- // tokens removed here will be restored after rejected transaction
- for ((collection, token), _) in <TokenChildren<T>>::iter_prefix((collection.id, token)) {
- ensure!(breadth_budget.consume(), <StructureError<T>>::BreadthLimit,);
- let PostDispatchInfo { actual_weight, .. } =
- <PalletStructure<T>>::burn_item_recursively(
- current_token_account.clone(),
- collection,
- token,
- self_budget,
- breadth_budget,
- )?;
- if let Some(actual_weight) = actual_weight {
- weight = weight.saturating_add(actual_weight);
- }
- }
-
- Self::burn(collection, sender, token)?;
- DispatchResultWithPostInfo::Ok(PostDispatchInfo {
- actual_weight: Some(weight + <SelfWeightOf<T>>::burn_item()),
- pays_fee: Pays::Yes,
- })
- }
-
/// A batch operation to add, edit or remove properties for a token.
///
/// - `nesting_budget`: Limit for searching parents in-depth to check ownership.
@@ -568,7 +523,7 @@
nesting_budget: &dyn Budget,
) -> DispatchResult {
let mut property_writer =
- pallet_common::property_writer_for_existing_token(collection, sender);
+ pallet_common::ExistingTokenPropertyWriter::new(collection, sender);
property_writer.write_token_properties(
sender,
@@ -915,7 +870,7 @@
// =========
- let mut property_writer = pallet_common::property_writer_for_new_token(collection, sender);
+ let mut property_writer = pallet_common::NewTokenPropertyWriter::new(collection, sender);
with_transaction(|| {
for (i, data) in data.iter().enumerate() {
pallets/nonfungible/src/weights.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/weights.rs
+++ b/pallets/nonfungible/src/weights.rs
@@ -3,13 +3,13 @@
//! Autogenerated weights for pallet_nonfungible
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-09-30, STEPS: `50`, REPEAT: `400`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-10-13, STEPS: `50`, REPEAT: `80`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `bench-host`, CPU: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
+//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
// Executed Command:
-// target/production/unique-collator
+// ./target/production/unique-collator
// benchmark
// pallet
// --pallet
@@ -20,7 +20,7 @@
// *
// --template=.maintain/frame-weight-template.hbs
// --steps=50
-// --repeat=400
+// --repeat=80
// --heap-pages=4096
// --output=./pallets/nonfungible/src/weights.rs
@@ -37,18 +37,14 @@
fn create_multiple_items(b: u32, ) -> Weight;
fn create_multiple_items_ex(b: u32, ) -> Weight;
fn burn_item() -> Weight;
- fn burn_recursively_self_raw() -> Weight;
- fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight;
fn transfer_raw() -> Weight;
fn approve() -> Weight;
fn approve_from() -> Weight;
fn check_allowed_raw() -> Weight;
fn burn_from() -> Weight;
+ fn load_token_properties() -> Weight;
+ fn write_token_properties(b: u32, ) -> Weight;
fn set_token_property_permissions(b: u32, ) -> Weight;
- fn set_token_properties(b: u32, ) -> Weight;
- fn init_token_properties(b: u32, ) -> Weight;
- fn delete_token_properties(b: u32, ) -> Weight;
- fn token_owner() -> Weight;
fn set_allowance_for_all() -> Weight;
fn allowance_for_all() -> Weight;
fn repair_item() -> Weight;
@@ -57,321 +53,231 @@
/// Weights for pallet_nonfungible using the Substrate node and recommended hardware.
pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn create_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3530`
- // Minimum execution time: 9_726_000 picoseconds.
- Weight::from_parts(10_059_000, 3530)
+ // Minimum execution time: 15_410_000 picoseconds.
+ Weight::from_parts(15_850_000, 3530)
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:200)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:200)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:200)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:200)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3530`
- // Minimum execution time: 3_270_000 picoseconds.
- Weight::from_parts(3_693_659, 3530)
- // Standard Error: 255
- .saturating_add(Weight::from_parts(3_024_284, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_300_000 picoseconds.
+ Weight::from_parts(5_992_994, 3530)
+ // Standard Error: 4_478
+ .saturating_add(Weight::from_parts(8_002_092, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(2_u64))
.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(b.into())))
}
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:200 w:200)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:200)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:200)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:200)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:200)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 3_188_000 picoseconds.
- Weight::from_parts(3_307_000, 3481)
- // Standard Error: 567
- .saturating_add(Weight::from_parts(4_320_449, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_300_000 picoseconds.
+ Weight::from_parts(3_980_000, 3481)
+ // Standard Error: 1_382
+ .saturating_add(Weight::from_parts(11_259_286, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(T::DbWeight::get().writes(1_u64))
.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `380`
// Estimated: `3530`
- // Minimum execution time: 18_062_000 picoseconds.
- Weight::from_parts(18_433_000, 3530)
- .saturating_add(T::DbWeight::get().reads(5_u64))
- .saturating_add(T::DbWeight::get().writes(5_u64))
- }
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- fn burn_recursively_self_raw() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `380`
- // Estimated: `3530`
- // Minimum execution time: 22_942_000 picoseconds.
- Weight::from_parts(23_527_000, 3530)
+ // Minimum execution time: 26_360_000 picoseconds.
+ Weight::from_parts(26_850_000, 3530)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(5_u64))
- }
- /// Storage: Nonfungible TokenChildren (r:401 w:200)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Common CollectionById (r:1 w:0)
- /// Proof: Common CollectionById (max_values: None, max_size: Some(860), added: 3335, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:201 w:201)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:2 w:2)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:201 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:201)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:201)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 200]`.
- fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `1500 + b * (58 ±0)`
- // Estimated: `5874 + b * (5032 ±0)`
- // Minimum execution time: 22_709_000 picoseconds.
- Weight::from_parts(23_287_000, 5874)
- // Standard Error: 89_471
- .saturating_add(Weight::from_parts(63_285_201, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(7_u64))
- .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(b.into())))
- .saturating_add(T::DbWeight::get().writes(6_u64))
- .saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(b.into())))
- .saturating_add(Weight::from_parts(0, 5032).saturating_mul(b.into()))
}
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:2 w:2)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:2)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:2)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_raw() -> Weight {
// Proof Size summary in bytes:
// Measured: `380`
// Estimated: `6070`
- // Minimum execution time: 13_652_000 picoseconds.
- Weight::from_parts(13_981_000, 6070)
+ // Minimum execution time: 22_710_000 picoseconds.
+ Weight::from_parts(23_130_000, 6070)
.saturating_add(T::DbWeight::get().reads(4_u64))
.saturating_add(T::DbWeight::get().writes(5_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn approve() -> Weight {
// Proof Size summary in bytes:
// Measured: `326`
// Estimated: `3522`
- // Minimum execution time: 7_837_000 picoseconds.
- Weight::from_parts(8_113_000, 3522)
+ // Minimum execution time: 11_520_000 picoseconds.
+ Weight::from_parts(12_030_000, 3522)
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn approve_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `313`
// Estimated: `3522`
- // Minimum execution time: 7_769_000 picoseconds.
- Weight::from_parts(7_979_000, 3522)
+ // Minimum execution time: 11_570_000 picoseconds.
+ Weight::from_parts(12_139_000, 3522)
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn check_allowed_raw() -> Weight {
// Proof Size summary in bytes:
// Measured: `362`
// Estimated: `3522`
- // Minimum execution time: 4_194_000 picoseconds.
- Weight::from_parts(4_353_000, 3522)
+ // Minimum execution time: 4_210_000 picoseconds.
+ Weight::from_parts(4_350_000, 3522)
.saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `463`
// Estimated: `3530`
- // Minimum execution time: 21_978_000 picoseconds.
- Weight::from_parts(22_519_000, 3530)
+ // Minimum execution time: 32_230_000 picoseconds.
+ Weight::from_parts(33_210_000, 3530)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(6_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:1)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_property_permissions(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `314`
- // Estimated: `20191`
- // Minimum execution time: 1_457_000 picoseconds.
- Weight::from_parts(1_563_000, 20191)
- // Standard Error: 14_041
- .saturating_add(Weight::from_parts(8_452_415, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(1_u64))
- .saturating_add(T::DbWeight::get().writes(1_u64))
- }
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_properties(b: u32, ) -> Weight {
+ /// Storage: `Nonfungible::TokenProperties` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
+ fn load_token_properties() -> Weight {
// Proof Size summary in bytes:
- // Measured: `640 + b * (261 ±0)`
+ // Measured: `279`
// Estimated: `36269`
- // Minimum execution time: 963_000 picoseconds.
- Weight::from_parts(1_126_511, 36269)
- // Standard Error: 9_175
- .saturating_add(Weight::from_parts(5_096_011, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(3_u64))
- .saturating_add(T::DbWeight::get().writes(1_u64))
+ // Minimum execution time: 3_180_000 picoseconds.
+ Weight::from_parts(3_370_000, 36269)
+ .saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn init_token_properties(b: u32, ) -> Weight {
+ fn write_token_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 194_000 picoseconds.
- Weight::from_parts(222_000, 0)
- // Standard Error: 7_295
- .saturating_add(Weight::from_parts(4_499_463, 0).saturating_mul(b.into()))
+ // Minimum execution time: 440_000 picoseconds.
+ Weight::from_parts(3_567_990, 0)
+ // Standard Error: 24_013
+ .saturating_add(Weight::from_parts(19_386_123, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn delete_token_properties(b: u32, ) -> Weight {
+ fn set_token_property_permissions(b: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `699 + b * (33291 ±0)`
- // Estimated: `36269`
- // Minimum execution time: 992_000 picoseconds.
- Weight::from_parts(1_043_000, 36269)
- // Standard Error: 37_370
- .saturating_add(Weight::from_parts(23_672_870, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(3_u64))
+ // Measured: `314`
+ // Estimated: `20191`
+ // Minimum execution time: 1_460_000 picoseconds.
+ Weight::from_parts(1_530_000, 20191)
+ // Standard Error: 124_929
+ .saturating_add(Weight::from_parts(28_397_581, 0).saturating_mul(b.into()))
+ .saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- fn token_owner() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `326`
- // Estimated: `3522`
- // Minimum execution time: 3_743_000 picoseconds.
- Weight::from_parts(3_908_000, 3522)
- .saturating_add(T::DbWeight::get().reads(1_u64))
- }
- /// Storage: Nonfungible CollectionAllowance (r:0 w:1)
- /// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::CollectionAllowance` (r:0 w:1)
+ /// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn set_allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_106_000 picoseconds.
- Weight::from_parts(4_293_000, 0)
+ // Minimum execution time: 6_840_000 picoseconds.
+ Weight::from_parts(7_160_000, 0)
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible CollectionAllowance (r:1 w:0)
- /// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::CollectionAllowance` (r:1 w:0)
+ /// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3576`
- // Minimum execution time: 2_775_000 picoseconds.
- Weight::from_parts(2_923_000, 3576)
+ // Minimum execution time: 3_630_000 picoseconds.
+ Weight::from_parts(3_780_000, 3576)
.saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenProperties` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn repair_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `279`
// Estimated: `36269`
- // Minimum execution time: 3_033_000 picoseconds.
- Weight::from_parts(3_174_000, 36269)
+ // Minimum execution time: 3_280_000 picoseconds.
+ Weight::from_parts(3_480_000, 36269)
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
@@ -379,321 +285,231 @@
// For backwards compatibility and tests
impl WeightInfo for () {
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn create_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3530`
- // Minimum execution time: 9_726_000 picoseconds.
- Weight::from_parts(10_059_000, 3530)
+ // Minimum execution time: 15_410_000 picoseconds.
+ Weight::from_parts(15_850_000, 3530)
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:200)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:200)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:200)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:200)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3530`
- // Minimum execution time: 3_270_000 picoseconds.
- Weight::from_parts(3_693_659, 3530)
- // Standard Error: 255
- .saturating_add(Weight::from_parts(3_024_284, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_300_000 picoseconds.
+ Weight::from_parts(5_992_994, 3530)
+ // Standard Error: 4_478
+ .saturating_add(Weight::from_parts(8_002_092, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(2_u64))
.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(b.into())))
}
- /// Storage: Nonfungible TokensMinted (r:1 w:1)
- /// Proof: Nonfungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:200 w:200)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:0 w:200)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:200)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:0 w:200)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:200)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 3_188_000 picoseconds.
- Weight::from_parts(3_307_000, 3481)
- // Standard Error: 567
- .saturating_add(Weight::from_parts(4_320_449, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_300_000 picoseconds.
+ Weight::from_parts(3_980_000, 3481)
+ // Standard Error: 1_382
+ .saturating_add(Weight::from_parts(11_259_286, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(RocksDbWeight::get().writes(1_u64))
.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `380`
// Estimated: `3530`
- // Minimum execution time: 18_062_000 picoseconds.
- Weight::from_parts(18_433_000, 3530)
- .saturating_add(RocksDbWeight::get().reads(5_u64))
- .saturating_add(RocksDbWeight::get().writes(5_u64))
- }
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- fn burn_recursively_self_raw() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `380`
- // Estimated: `3530`
- // Minimum execution time: 22_942_000 picoseconds.
- Weight::from_parts(23_527_000, 3530)
+ // Minimum execution time: 26_360_000 picoseconds.
+ Weight::from_parts(26_850_000, 3530)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(5_u64))
}
- /// Storage: Nonfungible TokenChildren (r:401 w:200)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Common CollectionById (r:1 w:0)
- /// Proof: Common CollectionById (max_values: None, max_size: Some(860), added: 3335, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:201 w:201)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:2 w:2)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:201 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:201)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:201)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 200]`.
- fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `1500 + b * (58 ±0)`
- // Estimated: `5874 + b * (5032 ±0)`
- // Minimum execution time: 22_709_000 picoseconds.
- Weight::from_parts(23_287_000, 5874)
- // Standard Error: 89_471
- .saturating_add(Weight::from_parts(63_285_201, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(7_u64))
- .saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(b.into())))
- .saturating_add(RocksDbWeight::get().writes(6_u64))
- .saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(b.into())))
- .saturating_add(Weight::from_parts(0, 5032).saturating_mul(b.into()))
- }
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:2 w:2)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:2)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:2)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_raw() -> Weight {
// Proof Size summary in bytes:
// Measured: `380`
// Estimated: `6070`
- // Minimum execution time: 13_652_000 picoseconds.
- Weight::from_parts(13_981_000, 6070)
+ // Minimum execution time: 22_710_000 picoseconds.
+ Weight::from_parts(23_130_000, 6070)
.saturating_add(RocksDbWeight::get().reads(4_u64))
.saturating_add(RocksDbWeight::get().writes(5_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn approve() -> Weight {
// Proof Size summary in bytes:
// Measured: `326`
// Estimated: `3522`
- // Minimum execution time: 7_837_000 picoseconds.
- Weight::from_parts(8_113_000, 3522)
+ // Minimum execution time: 11_520_000 picoseconds.
+ Weight::from_parts(12_030_000, 3522)
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn approve_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `313`
// Estimated: `3522`
- // Minimum execution time: 7_769_000 picoseconds.
- Weight::from_parts(7_979_000, 3522)
+ // Minimum execution time: 11_570_000 picoseconds.
+ Weight::from_parts(12_139_000, 3522)
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible Allowance (r:1 w:0)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:0)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
fn check_allowed_raw() -> Weight {
// Proof Size summary in bytes:
// Measured: `362`
// Estimated: `3522`
- // Minimum execution time: 4_194_000 picoseconds.
- Weight::from_parts(4_353_000, 3522)
+ // Minimum execution time: 4_210_000 picoseconds.
+ Weight::from_parts(4_350_000, 3522)
.saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible Allowance (r:1 w:1)
- /// Proof: Nonfungible Allowance (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:1)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenChildren (r:1 w:0)
- /// Proof: Nonfungible TokenChildren (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokensBurnt (r:1 w:1)
- /// Proof: Nonfungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Nonfungible AccountBalance (r:1 w:1)
- /// Proof: Nonfungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Nonfungible Owned (r:0 w:1)
- /// Proof: Nonfungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::Allowance` (r:1 w:1)
+ /// Proof: `Nonfungible::Allowance` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenData` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenData` (`max_values`: None, `max_size`: Some(57), added: 2532, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenChildren` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenChildren` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Nonfungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Nonfungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::Owned` (r:0 w:1)
+ /// Proof: `Nonfungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `463`
// Estimated: `3530`
- // Minimum execution time: 21_978_000 picoseconds.
- Weight::from_parts(22_519_000, 3530)
+ // Minimum execution time: 32_230_000 picoseconds.
+ Weight::from_parts(33_210_000, 3530)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(6_u64))
- }
- /// Storage: Common CollectionPropertyPermissions (r:1 w:1)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_property_permissions(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `314`
- // Estimated: `20191`
- // Minimum execution time: 1_457_000 picoseconds.
- Weight::from_parts(1_563_000, 20191)
- // Standard Error: 14_041
- .saturating_add(Weight::from_parts(8_452_415, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(1_u64))
- .saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_properties(b: u32, ) -> Weight {
+ /// Storage: `Nonfungible::TokenProperties` (r:1 w:0)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
+ fn load_token_properties() -> Weight {
// Proof Size summary in bytes:
- // Measured: `640 + b * (261 ±0)`
+ // Measured: `279`
// Estimated: `36269`
- // Minimum execution time: 963_000 picoseconds.
- Weight::from_parts(1_126_511, 36269)
- // Standard Error: 9_175
- .saturating_add(Weight::from_parts(5_096_011, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(3_u64))
- .saturating_add(RocksDbWeight::get().writes(1_u64))
+ // Minimum execution time: 3_180_000 picoseconds.
+ Weight::from_parts(3_370_000, 36269)
+ .saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible TokenProperties (r:0 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn init_token_properties(b: u32, ) -> Weight {
+ fn write_token_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 194_000 picoseconds.
- Weight::from_parts(222_000, 0)
- // Standard Error: 7_295
- .saturating_add(Weight::from_parts(4_499_463, 0).saturating_mul(b.into()))
+ // Minimum execution time: 440_000 picoseconds.
+ Weight::from_parts(3_567_990, 0)
+ // Standard Error: 24_013
+ .saturating_add(Weight::from_parts(19_386_123, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn delete_token_properties(b: u32, ) -> Weight {
+ fn set_token_property_permissions(b: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `699 + b * (33291 ±0)`
- // Estimated: `36269`
- // Minimum execution time: 992_000 picoseconds.
- Weight::from_parts(1_043_000, 36269)
- // Standard Error: 37_370
- .saturating_add(Weight::from_parts(23_672_870, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(3_u64))
+ // Measured: `314`
+ // Estimated: `20191`
+ // Minimum execution time: 1_460_000 picoseconds.
+ Weight::from_parts(1_530_000, 20191)
+ // Standard Error: 124_929
+ .saturating_add(Weight::from_parts(28_397_581, 0).saturating_mul(b.into()))
+ .saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible TokenData (r:1 w:0)
- /// Proof: Nonfungible TokenData (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
- fn token_owner() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `326`
- // Estimated: `3522`
- // Minimum execution time: 3_743_000 picoseconds.
- Weight::from_parts(3_908_000, 3522)
- .saturating_add(RocksDbWeight::get().reads(1_u64))
- }
- /// Storage: Nonfungible CollectionAllowance (r:0 w:1)
- /// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::CollectionAllowance` (r:0 w:1)
+ /// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn set_allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_106_000 picoseconds.
- Weight::from_parts(4_293_000, 0)
+ // Minimum execution time: 6_840_000 picoseconds.
+ Weight::from_parts(7_160_000, 0)
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Nonfungible CollectionAllowance (r:1 w:0)
- /// Proof: Nonfungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::CollectionAllowance` (r:1 w:0)
+ /// Proof: `Nonfungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `142`
// Estimated: `3576`
- // Minimum execution time: 2_775_000 picoseconds.
- Weight::from_parts(2_923_000, 3576)
+ // Minimum execution time: 3_630_000 picoseconds.
+ Weight::from_parts(3_780_000, 3576)
.saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Nonfungible TokenProperties (r:1 w:1)
- /// Proof: Nonfungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Nonfungible::TokenProperties` (r:1 w:1)
+ /// Proof: `Nonfungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn repair_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `279`
// Estimated: `36269`
- // Minimum execution time: 3_033_000 picoseconds.
- Weight::from_parts(3_174_000, 36269)
+ // Minimum execution time: 3_280_000 picoseconds.
+ Weight::from_parts(3_480_000, 36269)
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
pallets/refungible/src/benchmarking.rsdiffbeforeafterboth--- a/pallets/refungible/src/benchmarking.rs
+++ b/pallets/refungible/src/benchmarking.rs
@@ -19,10 +19,7 @@
use frame_benchmarking::v2::*;
use pallet_common::{
bench_init,
- benchmarking::{
- create_collection_raw, /*load_is_admin_and_property_permissions,*/ property_key,
- property_value,
- },
+ benchmarking::{create_collection_raw, property_key, property_value},
};
use sp_std::prelude::*;
use up_data_structs::{
@@ -425,38 +422,29 @@
}
#[benchmark]
- fn set_token_property_permissions(
- b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
- ) -> Result<(), BenchmarkError> {
+ fn load_token_properties() -> Result<(), BenchmarkError> {
bench_init! {
owner: sub; collection: collection(owner);
owner: cross_from_sub;
};
- let perms = (0..b)
- .map(|k| PropertyKeyPermission {
- key: property_key(k as usize),
- permission: PropertyPermission {
- mutable: false,
- collection_admin: false,
- token_owner: false,
- },
- })
- .collect::<Vec<_>>();
+ let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
+
#[block]
{
- <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
+ pallet_common::BenchmarkPropertyWriter::<T>::load_token_properties(&collection, item);
}
Ok(())
}
#[benchmark]
- fn set_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
+ fn write_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
bench_init! {
owner: sub; collection: collection(owner);
owner: cross_from_sub;
};
+
let perms = (0..b)
.map(|k| PropertyKeyPermission {
key: property_key(k as usize),
@@ -476,73 +464,29 @@
.collect::<Vec<_>>();
let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
+ let lazy_collection_info =
+ pallet_common::BenchmarkPropertyWriter::<T>::load_collection_info(&collection, &owner);
+
#[block]
{
- <Pallet<T>>::set_token_properties(
- &collection,
- &owner,
+ let mut property_writer =
+ pallet_common::BenchmarkPropertyWriter::new(&collection, lazy_collection_info);
+
+ property_writer.write_token_properties(
item,
props.into_iter(),
- &Unlimited,
+ crate::erc::ERC721TokenEvent::TokenChanged {
+ token_id: item.into(),
+ }
+ .to_log(T::ContractAddress::get()),
)?;
}
Ok(())
}
- // TODO:
#[benchmark]
- fn init_token_properties(b: Linear<0, MAX_PROPERTIES_PER_ITEM>) -> Result<(), BenchmarkError> {
- // bench_init! {
- // owner: sub; collection: collection(owner);
- // owner: cross_from_sub;
- // };
-
- // let perms = (0..b)
- // .map(|k| PropertyKeyPermission {
- // key: property_key(k as usize),
- // permission: PropertyPermission {
- // mutable: false,
- // collection_admin: true,
- // token_owner: true,
- // },
- // })
- // .collect::<Vec<_>>();
- // <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
-
- #[block]
- {}
- // let props = (0..b).map(|k| Property {
- // key: property_key(k as usize),
- // value: property_value(),
- // }).collect::<Vec<_>>();
- // let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
-
- // let (is_collection_admin, property_permissions) = load_is_admin_and_property_permissions(&collection, &owner)
- // let mut property_writer = pallet_common::collection_info_loaded_property_writer(
- // &collection,
- // is_collection_admin,
- // property_permissions,
- // );
-
- // #[block]
- // {
- // property_writer.write_token_properties(
- // true,
- // item,
- // props.into_iter(),
- // crate::erc::ERC721TokenEvent::TokenChanged {
- // token_id: item.into(),
- // }
- // .to_log(T::ContractAddress::get()),
- // )?;
- // }
-
- Ok(())
- }
-
- #[benchmark]
- fn delete_token_properties(
+ fn set_token_property_permissions(
b: Linear<0, MAX_PROPERTIES_PER_ITEM>,
) -> Result<(), BenchmarkError> {
bench_init! {
@@ -553,38 +497,16 @@
.map(|k| PropertyKeyPermission {
key: property_key(k as usize),
permission: PropertyPermission {
- mutable: true,
- collection_admin: true,
- token_owner: true,
+ mutable: false,
+ collection_admin: false,
+ token_owner: false,
},
- })
- .collect::<Vec<_>>();
- <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
- let props = (0..b)
- .map(|k| Property {
- key: property_key(k as usize),
- value: property_value(),
})
.collect::<Vec<_>>();
- let item = create_max_item(&collection, &owner, [(owner.clone(), 200)])?;
- <Pallet<T>>::set_token_properties(
- &collection,
- &owner,
- item,
- props.into_iter(),
- &Unlimited,
- )?;
- let to_delete = (0..b).map(|k| property_key(k as usize)).collect::<Vec<_>>();
#[block]
{
- <Pallet<T>>::delete_token_properties(
- &collection,
- &owner,
- item,
- to_delete.into_iter(),
- &Unlimited,
- )?;
+ <Pallet<T>>::set_token_property_permissions(&collection, &owner, perms)?;
}
Ok(())
@@ -601,22 +523,6 @@
#[block]
{
<Pallet<T>>::repartition(&collection, &owner, item, 200)?;
- }
-
- Ok(())
- }
-
- #[benchmark]
- fn token_owner() -> Result<(), BenchmarkError> {
- bench_init! {
- owner: sub; collection: collection(owner);
- sender: cross_from_sub(owner); owner: cross_sub;
- };
- let item = create_max_item(&collection, &sender, [(owner, 100)])?;
-
- #[block]
- {
- <Pallet<T>>::token_owner(collection.id, item).unwrap();
}
Ok(())
pallets/refungible/src/common.rsdiffbeforeafterboth--- a/pallets/refungible/src/common.rs
+++ b/pallets/refungible/src/common.rs
@@ -16,14 +16,12 @@
use core::marker::PhantomData;
-use frame_support::{
- dispatch::DispatchResultWithPostInfo, ensure, fail, traits::Get, weights::Weight,
-};
+use frame_support::{dispatch::DispatchResultWithPostInfo, fail, weights::Weight};
use pallet_common::{
- init_token_properties_delta, weights::WeightInfo as _, with_weight, CommonCollectionOperations,
- CommonWeightInfo, RefungibleExtensions,
+ weights::WeightInfo as _, with_weight, write_token_properties_total_weight,
+ CommonCollectionOperations, CommonWeightInfo, RefungibleExtensions,
};
-use pallet_structure::{Error as StructureError, Pallet as PalletStructure};
+use pallet_structure::Pallet as PalletStructure;
use sp_runtime::DispatchError;
use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec};
use up_data_structs::{
@@ -49,35 +47,27 @@
pub struct CommonWeights<T: Config>(PhantomData<T>);
impl<T: Config> CommonWeightInfo<T::CrossAccountId> for CommonWeights<T> {
fn create_multiple_items(data: &[up_data_structs::CreateItemData]) -> Weight {
- <SelfWeightOf<T>>::create_multiple_items(data.len() as u32).saturating_add(
- init_token_properties_delta::<T, _>(
- data.iter().map(|data| match data {
- up_data_structs::CreateItemData::ReFungible(rft_data) => {
- rft_data.properties.len() as u32
- }
- _ => 0,
- }),
- <SelfWeightOf<T>>::init_token_properties,
- ),
+ mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items(data.len() as u32),
+ data.iter().map(|data| match data {
+ up_data_structs::CreateItemData::ReFungible(rft_data) => {
+ rft_data.properties.len() as u32
+ }
+ _ => 0,
+ }),
)
}
fn create_multiple_items_ex(call: &CreateItemExData<T::CrossAccountId>) -> Weight {
match call {
- CreateItemExData::RefungibleMultipleOwners(i) => {
- <SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32)
- .saturating_add(init_token_properties_delta::<T, _>(
- [i.properties.len() as u32].into_iter(),
- <SelfWeightOf<T>>::init_token_properties,
- ))
- }
- CreateItemExData::RefungibleMultipleItems(i) => {
- <SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32)
- .saturating_add(init_token_properties_delta::<T, _>(
- i.iter().map(|d| d.properties.len() as u32),
- <SelfWeightOf<T>>::init_token_properties,
- ))
- }
+ CreateItemExData::RefungibleMultipleOwners(i) => mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(i.users.len() as u32),
+ [i.properties.len() as u32].into_iter(),
+ ),
+ CreateItemExData::RefungibleMultipleItems(i) => mint_with_props_weight::<T>(
+ <SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(i.len() as u32),
+ i.iter().map(|d| d.properties.len() as u32),
+ ),
_ => Weight::zero(),
}
}
@@ -88,18 +78,13 @@
fn set_collection_properties(amount: u32) -> Weight {
<pallet_common::SelfWeightOf<T>>::set_collection_properties(amount)
- }
-
- fn delete_collection_properties(amount: u32) -> Weight {
- <pallet_common::SelfWeightOf<T>>::delete_collection_properties(amount)
}
fn set_token_properties(amount: u32) -> Weight {
- <SelfWeightOf<T>>::set_token_properties(amount)
- }
-
- fn delete_token_properties(amount: u32) -> Weight {
- <SelfWeightOf<T>>::delete_token_properties(amount)
+ write_token_properties_total_weight::<T, _>([amount].into_iter(), |amount| {
+ <SelfWeightOf<T>>::load_token_properties()
+ .saturating_add(<SelfWeightOf<T>>::write_token_properties(amount))
+ })
}
fn set_token_property_permissions(amount: u32) -> Weight {
@@ -136,19 +121,6 @@
<SelfWeightOf<T>>::burn_from()
}
- fn burn_recursively_self_raw() -> Weight {
- // Read to get total balance
- Self::burn_item() + T::DbWeight::get().reads(1)
- }
- fn burn_recursively_breadth_raw(_amount: u32) -> Weight {
- // Refungible token can't have children
- Weight::zero()
- }
-
- fn token_owner() -> Weight {
- <SelfWeightOf<T>>::token_owner()
- }
-
fn set_allowance_for_all() -> Weight {
<SelfWeightOf<T>>::set_allowance_for_all()
}
@@ -158,6 +130,20 @@
}
}
+/// Weight of minting tokens with properties
+/// * `create_no_data_weight` -- the weight of minting without properties
+/// * `token_properties_nums` -- number of properties of each token
+#[inline]
+pub(crate) fn mint_with_props_weight<T: Config>(
+ create_no_data_weight: Weight,
+ token_properties_nums: impl Iterator<Item = u32> + Clone,
+) -> Weight {
+ create_no_data_weight.saturating_add(write_token_properties_total_weight::<T, _>(
+ token_properties_nums,
+ <SelfWeightOf<T>>::write_token_properties,
+ ))
+}
+
fn map_create_data<T: Config>(
data: up_data_structs::CreateItemData,
to: &T::CrossAccountId,
@@ -262,25 +248,6 @@
with_weight(
<Pallet<T>>::burn(self, &sender, token, amount),
<CommonWeights<T>>::burn_item(),
- )
- }
-
- fn burn_item_recursively(
- &self,
- sender: T::CrossAccountId,
- token: TokenId,
- self_budget: &dyn Budget,
- _breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo {
- ensure!(self_budget.consume(), <StructureError<T>>::DepthLimit,);
- with_weight(
- <Pallet<T>>::burn(
- self,
- &sender,
- token,
- <Balance<T>>::get((self.id, token, &sender)),
- ),
- <CommonWeights<T>>::burn_recursively_self_raw(),
)
}
pallets/refungible/src/erc.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Refungible Pallet EVM API for tokens18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.2122extern crate alloc;2324use alloc::string::ToString;25use core::{26 char::{decode_utf16, REPLACEMENT_CHARACTER},27 convert::TryInto,28};2930use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, AbiCoder, ToLog};31use frame_support::{BoundedBTreeMap, BoundedVec};32use pallet_common::{33 erc::{static_property::key, CollectionCall, CommonEvmHandler},34 eth::{self, TokenUri},35 CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,36 Error as CommonError,37};38use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm_coder_substrate::{40 call, dispatch_to_evm,41 execution::{Error, PreDispatch, Result},42 frontier_contract,43};44use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};45use sp_core::{Get, H160, U256};46use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec};47use up_data_structs::{48 mapping::TokenAddressMapping, CollectionId, CollectionPropertiesVec, Property, PropertyKey,49 PropertyKeyPermission, PropertyPermission, TokenId, TokenOwnerError,50};5152use crate::{53 weights::WeightInfo, AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle,54 SelfWeightOf, TokenProperties, TokensMinted, TotalSupply,55};5657frontier_contract! {58 macro_rules! RefungibleHandle_result {...}59 impl<T: Config> Contract for RefungibleHandle<T> {...}60}6162pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);6364/// Rft events.65#[derive(ToLog)]66pub enum ERC721TokenEvent {67 /// The token has been changed.68 TokenChanged {69 /// Token ID.70 #[indexed]71 token_id: U256,72 },73}7475/// Token minting parameters76#[derive(AbiCoder, Default, Debug)]77pub struct OwnerPieces {78 /// Minted token owner79 pub owner: eth::CrossAddress,80 /// Number of token pieces81 pub pieces: u128,82}8384/// Token minting parameters85#[derive(AbiCoder, Default, Debug)]86pub struct MintTokenData {87 /// Minted token owner and number of pieces88 pub owners: Vec<OwnerPieces>,89 /// Minted token properties90 pub properties: Vec<eth::Property>,91}9293/// @title A contract that allows to set and delete token properties and change token property permissions.94#[solidity_interface(name = TokenProperties, events(ERC721TokenEvent), enum(derive(PreDispatch)), enum_attr(weight))]95impl<T: Config> RefungibleHandle<T> {96 /// @notice Set permissions for token property.97 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.98 /// @param key Property key.99 /// @param isMutable Permission to mutate property.100 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.101 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.102 #[solidity(hide)]103 #[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]104 fn set_token_property_permission(105 &mut self,106 caller: Caller,107 key: String,108 is_mutable: bool,109 collection_admin: bool,110 token_owner: bool,111 ) -> Result<()> {112 let caller = T::CrossAccountId::from_eth(caller);113 <Pallet<T>>::set_token_property_permissions(114 self,115 &caller,116 vec![PropertyKeyPermission {117 key: <Vec<u8>>::from(key)118 .try_into()119 .map_err(|_| "too long key")?,120 permission: PropertyPermission {121 mutable: is_mutable,122 collection_admin,123 token_owner,124 },125 }],126 )127 .map_err(dispatch_to_evm::<T>)128 }129130 /// @notice Set permissions for token property.131 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.132 /// @param permissions Permissions for keys.133 #[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]134 fn set_token_property_permissions(135 &mut self,136 caller: Caller,137 permissions: Vec<eth::TokenPropertyPermission>,138 ) -> Result<()> {139 let caller = T::CrossAccountId::from_eth(caller);140 let perms = eth::TokenPropertyPermission::into_property_key_permissions(permissions)?;141142 <Pallet<T>>::set_token_property_permissions(self, &caller, perms)143 .map_err(dispatch_to_evm::<T>)144 }145146 /// @notice Get permissions for token properties.147 fn token_property_permissions(&self) -> Result<Vec<eth::TokenPropertyPermission>> {148 let perms = <Pallet<T>>::token_property_permission(self.id);149 Ok(perms150 .into_iter()151 .map(eth::TokenPropertyPermission::from)152 .collect())153 }154155 /// @notice Set token property value.156 /// @dev Throws error if `msg.sender` has no permission to edit the property.157 /// @param tokenId ID of the token.158 /// @param key Property key.159 /// @param value Property value.160 #[solidity(hide)]161 #[weight(<SelfWeightOf<T>>::set_token_properties(1))]162 fn set_property(163 &mut self,164 caller: Caller,165 token_id: U256,166 key: String,167 value: Bytes,168 ) -> Result<()> {169 let caller = T::CrossAccountId::from_eth(caller);170 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;171 let key = <Vec<u8>>::from(key)172 .try_into()173 .map_err(|_| "key too long")?;174 let value = value.0.try_into().map_err(|_| "value too long")?;175176 let nesting_budget = self177 .recorder178 .weight_calls_budget(<StructureWeight<T>>::find_parent());179180 <Pallet<T>>::set_token_property(181 self,182 &caller,183 TokenId(token_id),184 Property { key, value },185 &nesting_budget,186 )187 .map_err(dispatch_to_evm::<T>)188 }189190 /// @notice Set token properties value.191 /// @dev Throws error if `msg.sender` has no permission to edit the property.192 /// @param tokenId ID of the token.193 /// @param properties settable properties194 #[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]195 fn set_properties(196 &mut self,197 caller: Caller,198 token_id: U256,199 properties: Vec<eth::Property>,200 ) -> Result<()> {201 let caller = T::CrossAccountId::from_eth(caller);202 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;203204 let nesting_budget = self205 .recorder206 .weight_calls_budget(<StructureWeight<T>>::find_parent());207208 let properties = properties209 .into_iter()210 .map(eth::Property::try_into)211 .collect::<Result<Vec<_>>>()?;212213 <Pallet<T>>::set_token_properties(214 self,215 &caller,216 TokenId(token_id),217 properties.into_iter(),218 &nesting_budget,219 )220 .map_err(dispatch_to_evm::<T>)221 }222223 /// @notice Delete token property value.224 /// @dev Throws error if `msg.sender` has no permission to edit the property.225 /// @param tokenId ID of the token.226 /// @param key Property key.227 #[solidity(hide)]228 #[weight(<SelfWeightOf<T>>::delete_token_properties(1))]229 fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {230 let caller = T::CrossAccountId::from_eth(caller);231 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;232 let key = <Vec<u8>>::from(key)233 .try_into()234 .map_err(|_| "key too long")?;235236 let nesting_budget = self237 .recorder238 .weight_calls_budget(<StructureWeight<T>>::find_parent());239240 <Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)241 .map_err(dispatch_to_evm::<T>)242 }243244 /// @notice Delete token properties value.245 /// @dev Throws error if `msg.sender` has no permission to edit the property.246 /// @param tokenId ID of the token.247 /// @param keys Properties key.248 #[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]249 fn delete_properties(250 &mut self,251 token_id: U256,252 caller: Caller,253 keys: Vec<String>,254 ) -> Result<()> {255 let caller = T::CrossAccountId::from_eth(caller);256 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;257 let keys = keys258 .into_iter()259 .map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))260 .collect::<Result<Vec<_>>>()?;261262 let nesting_budget = self263 .recorder264 .weight_calls_budget(<StructureWeight<T>>::find_parent());265266 <Pallet<T>>::delete_token_properties(267 self,268 &caller,269 TokenId(token_id),270 keys.into_iter(),271 &nesting_budget,272 )273 .map_err(dispatch_to_evm::<T>)274 }275276 /// @notice Get token property value.277 /// @dev Throws error if key not found278 /// @param tokenId ID of the token.279 /// @param key Property key.280 /// @return Property value bytes281 fn property(&self, token_id: U256, key: String) -> Result<Bytes> {282 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;283 let key = <Vec<u8>>::from(key)284 .try_into()285 .map_err(|_| "key too long")?;286287 let props =288 <TokenProperties<T>>::get((self.id, token_id)).ok_or("token properties not found")?;289 let prop = props.get(&key).ok_or("key not found")?;290291 Ok(prop.to_vec().into())292 }293}294295#[derive(ToLog)]296pub enum ERC721Events {297 /// @dev This event emits when NFTs are created (`from` == 0) and destroyed298 /// (`to` == 0). Exception: during contract creation, any number of RFTs299 /// may be created and assigned without emitting Transfer.300 Transfer {301 #[indexed]302 from: Address,303 #[indexed]304 to: Address,305 #[indexed]306 token_id: U256,307 },308 /// @dev Not supported309 Approval {310 #[indexed]311 owner: Address,312 #[indexed]313 approved: Address,314 #[indexed]315 token_id: U256,316 },317 /// @dev Not supported318 #[allow(dead_code)]319 ApprovalForAll {320 #[indexed]321 owner: Address,322 #[indexed]323 operator: Address,324 approved: bool,325 },326}327328/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension329/// @dev See https://eips.ethereum.org/EIPS/eip-721330#[solidity_interface(name = ERC721Metadata, enum(derive(PreDispatch)), expect_selector = 0x5b5e139f)]331impl<T: Config> RefungibleHandle<T>332where333 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,334{335 /// @notice A descriptive name for a collection of NFTs in this contract336 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`337 #[solidity(hide, rename_selector = "name")]338 fn name_proxy(&self) -> Result<String> {339 self.name()340 }341342 /// @notice An abbreviated name for NFTs in this contract343 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`344 #[solidity(hide, rename_selector = "symbol")]345 fn symbol_proxy(&self) -> Result<String> {346 self.symbol()347 }348349 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.350 ///351 /// @dev If the token has a `url` property and it is not empty, it is returned.352 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.353 /// If the collection property `baseURI` is empty or absent, return "" (empty string)354 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix355 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).356 ///357 /// @return token's const_metadata358 #[solidity(rename_selector = "tokenURI")]359 fn token_uri(&self, token_id: U256) -> Result<String> {360 let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;361362 match get_token_property(self, token_id_u32, &key::url()).as_deref() {363 Err(_) | Ok("") => (),364 Ok(url) => {365 return Ok(url.into());366 }367 };368369 let base_uri =370 pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())371 .map(BoundedVec::into_inner)372 .map(String::from_utf8)373 .transpose()374 .map_err(|e| {375 Error::Revert(alloc::format!(376 "can not convert value \"baseURI\" to string with error \"{e}\""377 ))378 })?;379380 let base_uri = match base_uri.as_deref() {381 None | Some("") => {382 return Ok("".into());383 }384 Some(base_uri) => base_uri.into(),385 };386387 Ok(388 match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {389 Err(_) | Ok("") => base_uri,390 Ok(suffix) => base_uri + suffix,391 },392 )393 }394}395396/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension397/// @dev See https://eips.ethereum.org/EIPS/eip-721398#[solidity_interface(name = ERC721Enumerable, enum(derive(PreDispatch)), expect_selector = 0x780e9d63)]399impl<T: Config> RefungibleHandle<T> {400 /// @notice Enumerate valid RFTs401 /// @param index A counter less than `totalSupply()`402 /// @return The token identifier for the `index`th NFT,403 /// (sort order not specified)404 fn token_by_index(&self, index: U256) -> U256 {405 index406 }407408 /// Not implemented409 fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {410 // TODO: Not implemetable411 Err("not implemented".into())412 }413414 /// @notice Count RFTs tracked by this contract415 /// @return A count of valid RFTs tracked by this contract, where each one of416 /// them has an assigned and queryable owner not equal to the zero address417 fn total_supply(&self) -> Result<U256> {418 self.consume_store_reads(1)?;419 Ok(<Pallet<T>>::total_supply(self).into())420 }421}422423/// @title ERC-721 Non-Fungible Token Standard424/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md425#[solidity_interface(name = ERC721, events(ERC721Events), enum(derive(PreDispatch)), enum_attr(weight), expect_selector = 0x80ac58cd)]426impl<T: Config> RefungibleHandle<T> {427 /// @notice Count all RFTs assigned to an owner428 /// @dev RFTs assigned to the zero address are considered invalid, and this429 /// function throws for queries about the zero address.430 /// @param owner An address for whom to query the balance431 /// @return The number of RFTs owned by `owner`, possibly zero432 fn balance_of(&self, owner: Address) -> Result<U256> {433 self.consume_store_reads(1)?;434 let owner = T::CrossAccountId::from_eth(owner);435 let balance = <AccountBalance<T>>::get((self.id, owner));436 Ok(balance.into())437 }438439 /// @notice Find the owner of an RFT440 /// @dev RFTs assigned to zero address are considered invalid, and queries441 /// about them do throw.442 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for443 /// the tokens that are partially owned.444 /// @param tokenId The identifier for an RFT445 /// @return The address of the owner of the RFT446 fn owner_of(&self, token_id: U256) -> Result<Address> {447 self.consume_store_reads(2)?;448 let token = token_id.try_into()?;449 let owner = <Pallet<T>>::token_owner(self.id, token);450 owner451 .map(|address| *address.as_eth())452 .or_else(|err| match err {453 TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),454 TokenOwnerError::MultipleOwners => Ok(ADDRESS_FOR_PARTIALLY_OWNED_TOKENS),455 })456 }457458 /// @dev Not implemented459 #[solidity(rename_selector = "safeTransferFrom")]460 fn safe_transfer_from_with_data(461 &mut self,462 _from: Address,463 _to: Address,464 _token_id: U256,465 _data: Bytes,466 ) -> Result<()> {467 // TODO: Not implemetable468 Err("not implemented".into())469 }470471 /// @dev Not implemented472 #[solidity(rename_selector = "safeTransferFrom")]473 fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {474 // TODO: Not implemetable475 Err("not implemented".into())476 }477478 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE479 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE480 /// THEY MAY BE PERMANENTLY LOST481 /// @dev Throws unless `msg.sender` is the current owner or an authorized482 /// operator for this RFT. Throws if `from` is not the current owner. Throws483 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.484 /// Throws if RFT pieces have multiple owners.485 /// @param from The current owner of the NFT486 /// @param to The new owner487 /// @param tokenId The NFT to transfer488 #[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]489 fn transfer_from(490 &mut self,491 caller: Caller,492 from: Address,493 to: Address,494 token_id: U256,495 ) -> Result<()> {496 let caller = T::CrossAccountId::from_eth(caller);497 let from = T::CrossAccountId::from_eth(from);498 let to = T::CrossAccountId::from_eth(to);499 let token = token_id.try_into()?;500 let budget = self501 .recorder502 .weight_calls_budget(<StructureWeight<T>>::find_parent());503504 let balance = balance(self, token, &from)?;505 ensure_single_owner(self, token, balance)?;506507 <Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)508 .map_err(dispatch_to_evm::<T>)?;509510 Ok(())511 }512513 /// @dev Not implemented514 fn approve(&mut self, _caller: Caller, _approved: Address, _token_id: U256) -> Result<()> {515 Err("not implemented".into())516 }517518 /// @notice Sets or unsets the approval of a given operator.519 /// The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.520 /// @param operator Operator521 /// @param approved Should operator status be granted or revoked?522 #[weight(<SelfWeightOf<T>>::set_allowance_for_all())]523 fn set_approval_for_all(524 &mut self,525 caller: Caller,526 operator: Address,527 approved: bool,528 ) -> Result<()> {529 let caller = T::CrossAccountId::from_eth(caller);530 let operator = T::CrossAccountId::from_eth(operator);531532 <Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)533 .map_err(dispatch_to_evm::<T>)?;534 Ok(())535 }536537 /// @dev Not implemented538 fn get_approved(&self, _token_id: U256) -> Result<Address> {539 // TODO: Not implemetable540 Err("not implemented".into())541 }542543 /// @notice Tells whether the given `owner` approves the `operator`.544 #[weight(<SelfWeightOf<T>>::allowance_for_all())]545 fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {546 let owner = T::CrossAccountId::from_eth(owner);547 let operator = T::CrossAccountId::from_eth(operator);548549 Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))550 }551}552553/// Returns amount of pieces of `token` that `owner` have554pub fn balance<T: Config>(555 collection: &RefungibleHandle<T>,556 token: TokenId,557 owner: &T::CrossAccountId,558) -> Result<u128> {559 collection.consume_store_reads(1)?;560 let balance = <Balance<T>>::get((collection.id, token, &owner));561 Ok(balance)562}563564/// Throws if `owner_balance` is lower than total amount of `token` pieces565pub fn ensure_single_owner<T: Config>(566 collection: &RefungibleHandle<T>,567 token: TokenId,568 owner_balance: u128,569) -> Result<()> {570 collection.consume_store_reads(1)?;571 let total_supply = <TotalSupply<T>>::get((collection.id, token));572573 if owner_balance == 0 {574 return Err(dispatch_to_evm::<T>(575 <CommonError<T>>::MustBeTokenOwner.into(),576 ));577 }578579 if total_supply != owner_balance {580 return Err("token has multiple owners".into());581 }582 Ok(())583}584585/// @title ERC721 Token that can be irreversibly burned (destroyed).586#[solidity_interface(name = ERC721Burnable, enum(derive(PreDispatch)), enum_attr(weight))]587impl<T: Config> RefungibleHandle<T> {588 /// @notice Burns a specific ERC721 token.589 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized590 /// operator of the current owner.591 /// @param tokenId The RFT to approve592 #[weight(<SelfWeightOf<T>>::burn_item_fully())]593 fn burn(&mut self, caller: Caller, token_id: U256) -> Result<()> {594 let caller = T::CrossAccountId::from_eth(caller);595 let token = token_id.try_into()?;596597 let balance = balance(self, token, &caller)?;598 ensure_single_owner(self, token, balance)?;599600 <Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;601 Ok(())602 }603}604605/// @title ERC721 minting logic.606#[solidity_interface(name = ERC721UniqueMintable, enum(derive(PreDispatch)), enum_attr(weight))]607impl<T: Config> RefungibleHandle<T> {608 /// @notice Function to mint a token.609 /// @param to The new owner610 /// @return uint256 The id of the newly minted token611 #[weight(<SelfWeightOf<T>>::create_item())]612 fn mint(&mut self, caller: Caller, to: Address) -> Result<U256> {613 let token_id: U256 = <TokensMinted<T>>::get(self.id)614 .checked_add(1)615 .ok_or("item id overflow")?616 .into();617 self.mint_check_id(caller, to, token_id)?;618 Ok(token_id)619 }620621 /// @notice Function to mint a token.622 /// @dev `tokenId` should be obtained with `nextTokenId` method,623 /// unlike standard, you can't specify it manually624 /// @param to The new owner625 /// @param tokenId ID of the minted RFT626 #[solidity(hide, rename_selector = "mint")]627 #[weight(<SelfWeightOf<T>>::create_item())]628 fn mint_check_id(&mut self, caller: Caller, to: Address, token_id: U256) -> Result<bool> {629 let caller = T::CrossAccountId::from_eth(caller);630 let to = T::CrossAccountId::from_eth(to);631 let token_id: u32 = token_id.try_into()?;632 let budget = self633 .recorder634 .weight_calls_budget(<StructureWeight<T>>::find_parent());635636 if <TokensMinted<T>>::get(self.id)637 .checked_add(1)638 .ok_or("item id overflow")?639 != token_id640 {641 return Err("item id should be next".into());642 }643644 let users = [(to, 1)]645 .into_iter()646 .collect::<BTreeMap<_, _>>()647 .try_into()648 .unwrap();649 <Pallet<T>>::create_item(650 self,651 &caller,652 CreateItemData::<T> {653 users,654 properties: CollectionPropertiesVec::default(),655 },656 &budget,657 )658 .map_err(dispatch_to_evm::<T>)?;659660 Ok(true)661 }662663 /// @notice Function to mint token with the given tokenUri.664 /// @param to The new owner665 /// @param tokenUri Token URI that would be stored in the NFT properties666 /// @return uint256 The id of the newly minted token667 #[solidity(rename_selector = "mintWithTokenURI")]668 #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]669 fn mint_with_token_uri(670 &mut self,671 caller: Caller,672 to: Address,673 token_uri: String,674 ) -> Result<U256> {675 let token_id: U256 = <TokensMinted<T>>::get(self.id)676 .checked_add(1)677 .ok_or("item id overflow")?678 .into();679 self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;680 Ok(token_id)681 }682683 /// @notice Function to mint token with the given tokenUri.684 /// @dev `tokenId` should be obtained with `nextTokenId` method,685 /// unlike standard, you can't specify it manually686 /// @param to The new owner687 /// @param tokenId ID of the minted RFT688 /// @param tokenUri Token URI that would be stored in the RFT properties689 #[solidity(hide, rename_selector = "mintWithTokenURI")]690 #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(1))]691 fn mint_with_token_uri_check_id(692 &mut self,693 caller: Caller,694 to: Address,695 token_id: U256,696 token_uri: String,697 ) -> Result<bool> {698 let key = key::url();699 let permission = get_token_permission::<T>(self.id, &key)?;700 if !permission.collection_admin {701 return Err("operation is not allowed".into());702 }703704 let caller = T::CrossAccountId::from_eth(caller);705 let to = T::CrossAccountId::from_eth(to);706 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;707 let budget = self708 .recorder709 .weight_calls_budget(<StructureWeight<T>>::find_parent());710711 if <TokensMinted<T>>::get(self.id)712 .checked_add(1)713 .ok_or("item id overflow")?714 != token_id715 {716 return Err("item id should be next".into());717 }718719 let mut properties = CollectionPropertiesVec::default();720 properties721 .try_push(Property {722 key,723 value: token_uri724 .into_bytes()725 .try_into()726 .map_err(|_| "token uri is too long")?,727 })728 .map_err(|e| Error::Revert(alloc::format!("can't add property: {e:?}")))?;729730 let users = [(to, 1)]731 .into_iter()732 .collect::<BTreeMap<_, _>>()733 .try_into()734 .unwrap();735 <Pallet<T>>::create_item(736 self,737 &caller,738 CreateItemData::<T> { users, properties },739 &budget,740 )741 .map_err(dispatch_to_evm::<T>)?;742 Ok(true)743 }744}745746fn get_token_property<T: Config>(747 collection: &CollectionHandle<T>,748 token_id: u32,749 key: &up_data_structs::PropertyKey,750) -> Result<String> {751 collection.consume_store_reads(1)?;752 let properties = <TokenProperties<T>>::try_get((collection.id, token_id))753 .map_err(|_| Error::Revert("token properties not found".into()))?;754 if let Some(property) = properties.get(key) {755 return Ok(String::from_utf8_lossy(property).into());756 }757758 Err("property tokenURI not found".into())759}760761fn get_token_permission<T: Config>(762 collection_id: CollectionId,763 key: &PropertyKey,764) -> Result<PropertyPermission> {765 let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)766 .map_err(|_| Error::Revert("no permissions for collection".into()))?;767 let a = token_property_permissions768 .get(key)769 .map(Clone::clone)770 .ok_or_else(|| {771 let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();772 Error::Revert(alloc::format!("no permission for key {key}"))773 })?;774 Ok(a)775}776777/// @title Unique extensions for ERC721.778#[solidity_interface(name = ERC721UniqueExtensions, enum(derive(PreDispatch)), enum_attr(weight))]779impl<T: Config> RefungibleHandle<T>780where781 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,782{783 /// @notice A descriptive name for a collection of NFTs in this contract784 fn name(&self) -> Result<String> {785 Ok(decode_utf16(self.name.iter().copied())786 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))787 .collect::<String>())788 }789790 /// @notice An abbreviated name for NFTs in this contract791 fn symbol(&self) -> Result<String> {792 Ok(String::from_utf8_lossy(&self.token_prefix).into())793 }794795 /// @notice A description for the collection.796 fn description(&self) -> Result<String> {797 Ok(decode_utf16(self.description.iter().copied())798 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))799 .collect::<String>())800 }801802 /// Returns the owner (in cross format) of the token.803 ///804 /// @param tokenId Id for the token.805 #[solidity(hide)]806 fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {807 Self::owner_of_cross(self, token_id)808 }809810 /// Returns the owner (in cross format) of the token.811 ///812 /// @param tokenId Id for the token.813 fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {814 Self::token_owner(self, token_id.try_into()?)815 .map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))816 .or_else(|err| match err {817 TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),818 TokenOwnerError::MultipleOwners => Ok(eth::CrossAddress::from_eth(819 ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,820 )),821 })822 }823824 /// @notice Count all RFTs assigned to an owner825 /// @param owner An cross address for whom to query the balance826 /// @return The number of RFTs owned by `owner`, possibly zero827 fn balance_of_cross(&self, owner: eth::CrossAddress) -> Result<U256> {828 self.consume_store_reads(1)?;829 let balance = <AccountBalance<T>>::get((self.id, owner.into_sub_cross_account::<T>()?));830 Ok(balance.into())831 }832833 /// Returns the token properties.834 ///835 /// @param tokenId Id for the token.836 /// @param keys Properties keys. Empty keys for all propertyes.837 /// @return Vector of properties key/value pairs.838 fn properties(&self, token_id: U256, keys: Vec<String>) -> Result<Vec<eth::Property>> {839 let keys = keys840 .into_iter()841 .map(|key| {842 <Vec<u8>>::from(key)843 .try_into()844 .map_err(|_| Error::Revert("key too large".into()))845 })846 .collect::<Result<Vec<_>>>()?;847848 <Self as CommonCollectionOperations<T>>::token_properties(849 self,850 token_id.try_into()?,851 if keys.is_empty() { None } else { Some(keys) },852 )853 .into_iter()854 .map(eth::Property::try_from)855 .collect::<Result<Vec<_>>>()856 }857 /// @notice Transfer ownership of an RFT858 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`859 /// is the zero address. Throws if `tokenId` is not a valid RFT.860 /// Throws if RFT pieces have multiple owners.861 /// @param to The new owner862 /// @param tokenId The RFT to transfer863 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]864 fn transfer(&mut self, caller: Caller, to: Address, token_id: U256) -> Result<()> {865 let caller = T::CrossAccountId::from_eth(caller);866 let to = T::CrossAccountId::from_eth(to);867 let token = token_id.try_into()?;868 let budget = self869 .recorder870 .weight_calls_budget(<StructureWeight<T>>::find_parent());871872 let balance = balance(self, token, &caller)?;873 ensure_single_owner(self, token, balance)?;874875 <Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)876 .map_err(dispatch_to_evm::<T>)?;877 Ok(())878 }879880 /// @notice Transfer ownership of an RFT881 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`882 /// is the zero address. Throws if `tokenId` is not a valid RFT.883 /// Throws if RFT pieces have multiple owners.884 /// @param to The new owner885 /// @param tokenId The RFT to transfer886 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]887 fn transfer_cross(888 &mut self,889 caller: Caller,890 to: eth::CrossAddress,891 token_id: U256,892 ) -> Result<()> {893 let caller = T::CrossAccountId::from_eth(caller);894 let to = to.into_sub_cross_account::<T>()?;895 let token = token_id.try_into()?;896 let budget = self897 .recorder898 .weight_calls_budget(<StructureWeight<T>>::find_parent());899900 let balance = balance(self, token, &caller)?;901 ensure_single_owner(self, token, balance)?;902903 <Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)904 .map_err(dispatch_to_evm::<T>)?;905 Ok(())906 }907908 /// @notice Transfer ownership of an RFT909 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`910 /// is the zero address. Throws if `tokenId` is not a valid RFT.911 /// Throws if RFT pieces have multiple owners.912 /// @param to The new owner913 /// @param tokenId The RFT to transfer914 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]915 fn transfer_from_cross(916 &mut self,917 caller: Caller,918 from: eth::CrossAddress,919 to: eth::CrossAddress,920 token_id: U256,921 ) -> Result<()> {922 let caller = T::CrossAccountId::from_eth(caller);923 let from = from.into_sub_cross_account::<T>()?;924 let to = to.into_sub_cross_account::<T>()?;925 let token_id = token_id.try_into()?;926 let budget = self927 .recorder928 .weight_calls_budget(<StructureWeight<T>>::find_parent());929930 let balance = balance(self, token_id, &from)?;931 ensure_single_owner(self, token_id, balance)?;932933 Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)934 .map_err(dispatch_to_evm::<T>)?;935 Ok(())936 }937938 /// @notice Burns a specific ERC721 token.939 /// @dev Throws unless `msg.sender` is the current owner or an authorized940 /// operator for this RFT. Throws if `from` is not the current owner. Throws941 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.942 /// Throws if RFT pieces have multiple owners.943 /// @param from The current owner of the RFT944 /// @param tokenId The RFT to transfer945 #[solidity(hide)]946 #[weight(<SelfWeightOf<T>>::burn_from())]947 fn burn_from(&mut self, caller: Caller, from: Address, token_id: U256) -> Result<()> {948 let caller = T::CrossAccountId::from_eth(caller);949 let from = T::CrossAccountId::from_eth(from);950 let token = token_id.try_into()?;951 let budget = self952 .recorder953 .weight_calls_budget(<StructureWeight<T>>::find_parent());954955 let balance = balance(self, token, &from)?;956 ensure_single_owner(self, token, balance)?;957958 <Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)959 .map_err(dispatch_to_evm::<T>)?;960 Ok(())961 }962963 /// @notice Burns a specific ERC721 token.964 /// @dev Throws unless `msg.sender` is the current owner or an authorized965 /// operator for this RFT. Throws if `from` is not the current owner. Throws966 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.967 /// Throws if RFT pieces have multiple owners.968 /// @param from The current owner of the RFT969 /// @param tokenId The RFT to transfer970 #[weight(<SelfWeightOf<T>>::burn_from())]971 fn burn_from_cross(972 &mut self,973 caller: Caller,974 from: eth::CrossAddress,975 token_id: U256,976 ) -> Result<()> {977 let caller = T::CrossAccountId::from_eth(caller);978 let from = from.into_sub_cross_account::<T>()?;979 let token = token_id.try_into()?;980 let budget = self981 .recorder982 .weight_calls_budget(<StructureWeight<T>>::find_parent());983984 let balance = balance(self, token, &from)?;985 ensure_single_owner(self, token, balance)?;986987 <Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)988 .map_err(dispatch_to_evm::<T>)?;989 Ok(())990 }991992 /// @notice Returns next free RFT ID.993 fn next_token_id(&self) -> Result<U256> {994 self.consume_store_reads(1)?;995 Ok(<Pallet<T>>::next_token_id(self)996 .map_err(dispatch_to_evm::<T>)?997 .into())998 }9991000 /// @notice Function to mint multiple tokens.1001 /// @dev `tokenIds` should be an array of consecutive numbers and first number1002 /// should be obtained with `nextTokenId` method1003 /// @param to The new owner1004 /// @param tokenIds IDs of the minted RFTs1005 #[solidity(hide)]1006 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]1007 fn mint_bulk(&mut self, caller: Caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {1008 let caller = T::CrossAccountId::from_eth(caller);1009 let to = T::CrossAccountId::from_eth(to);1010 let mut expected_index = <TokensMinted<T>>::get(self.id)1011 .checked_add(1)1012 .ok_or("item id overflow")?;1013 let budget = self1014 .recorder1015 .weight_calls_budget(<StructureWeight<T>>::find_parent());10161017 let total_tokens = token_ids.len();1018 for id in token_ids.into_iter() {1019 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1020 if id != expected_index {1021 return Err("item id should be next".into());1022 }1023 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1024 }1025 let users = [(to, 1)]1026 .into_iter()1027 .collect::<BTreeMap<_, _>>()1028 .try_into()1029 .unwrap();1030 let create_item_data = CreateItemData::<T> {1031 users,1032 properties: CollectionPropertiesVec::default(),1033 };1034 let data = (0..total_tokens)1035 .map(|_| create_item_data.clone())1036 .collect();10371038 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1039 .map_err(dispatch_to_evm::<T>)?;1040 Ok(true)1041 }10421043 /// @notice Function to mint a token.1044 /// @param tokenProperties Properties of minted token1045 #[weight(if token_properties.len() == 1 {1046 <SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(token_properties.iter().next().unwrap().owners.len() as u32)1047 } else {1048 <SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(token_properties.len() as u32)1049 } + <SelfWeightOf<T>>::set_token_properties(token_properties.len() as u32))]1050 fn mint_bulk_cross(1051 &mut self,1052 caller: Caller,1053 token_properties: Vec<MintTokenData>,1054 ) -> Result<bool> {1055 let caller = T::CrossAccountId::from_eth(caller);1056 let budget = self1057 .recorder1058 .weight_calls_budget(<StructureWeight<T>>::find_parent());1059 let has_multiple_tokens = token_properties.len() > 1;10601061 let mut create_rft_data = Vec::with_capacity(token_properties.len());1062 for MintTokenData { owners, properties } in token_properties {1063 let has_multiple_owners = owners.len() > 1;1064 if has_multiple_tokens & has_multiple_owners {1065 return Err(1066 "creation of multiple tokens supported only if they have single owner each"1067 .into(),1068 );1069 }1070 let users: BoundedBTreeMap<_, _, _> = owners1071 .into_iter()1072 .map(|data| Ok((data.owner.into_sub_cross_account::<T>()?, data.pieces)))1073 .collect::<Result<BTreeMap<_, _>>>()?1074 .try_into()1075 .map_err(|_| "too many users")?;1076 create_rft_data.push(CreateItemData::<T> {1077 properties: properties1078 .into_iter()1079 .map(|property| property.try_into())1080 .collect::<Result<Vec<_>>>()?1081 .try_into()1082 .map_err(|_| "too many properties")?,1083 users,1084 });1085 }10861087 <Pallet<T>>::create_multiple_items(self, &caller, create_rft_data, &budget)1088 .map_err(dispatch_to_evm::<T>)?;1089 Ok(true)1090 }10911092 /// @notice Function to mint multiple tokens with the given tokenUris.1093 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1094 /// numbers and first number should be obtained with `nextTokenId` method1095 /// @param to The new owner1096 /// @param tokens array of pairs of token ID and token URI for minted tokens1097 #[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1098 #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32) + <SelfWeightOf<T>>::set_token_properties(tokens.len() as u32))]1099 fn mint_bulk_with_token_uri(1100 &mut self,1101 caller: Caller,1102 to: Address,1103 tokens: Vec<TokenUri>,1104 ) -> Result<bool> {1105 let key = key::url();1106 let caller = T::CrossAccountId::from_eth(caller);1107 let to = T::CrossAccountId::from_eth(to);1108 let mut expected_index = <TokensMinted<T>>::get(self.id)1109 .checked_add(1)1110 .ok_or("item id overflow")?;1111 let budget = self1112 .recorder1113 .weight_calls_budget(<StructureWeight<T>>::find_parent());11141115 let mut data = Vec::with_capacity(tokens.len());1116 let users: BoundedBTreeMap<_, _, _> = [(to, 1)]1117 .into_iter()1118 .collect::<BTreeMap<_, _>>()1119 .try_into()1120 .unwrap();1121 for TokenUri { id, uri } in tokens {1122 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1123 if id != expected_index {1124 return Err("item id should be next".into());1125 }1126 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;11271128 let mut properties = CollectionPropertiesVec::default();1129 properties1130 .try_push(Property {1131 key: key.clone(),1132 value: uri1133 .into_bytes()1134 .try_into()1135 .map_err(|_| "token uri is too long")?,1136 })1137 .map_err(|e| Error::Revert(alloc::format!("can't add property: {e:?}")))?;11381139 let create_item_data = CreateItemData::<T> {1140 users: users.clone(),1141 properties,1142 };1143 data.push(create_item_data);1144 }11451146 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1147 .map_err(dispatch_to_evm::<T>)?;1148 Ok(true)1149 }11501151 /// @notice Function to mint a token.1152 /// @param to The new owner crossAccountId1153 /// @param properties Properties of minted token1154 /// @return uint256 The id of the newly minted token1155 #[weight(<SelfWeightOf<T>>::create_item() + <SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]1156 fn mint_cross(1157 &mut self,1158 caller: Caller,1159 to: eth::CrossAddress,1160 properties: Vec<eth::Property>,1161 ) -> Result<U256> {1162 let token_id = <TokensMinted<T>>::get(self.id)1163 .checked_add(1)1164 .ok_or("item id overflow")?;11651166 let to = to.into_sub_cross_account::<T>()?;11671168 let properties = properties1169 .into_iter()1170 .map(eth::Property::try_into)1171 .collect::<Result<Vec<_>>>()?1172 .try_into()1173 .map_err(|_| Error::Revert("too many properties".to_string()))?;11741175 let caller = T::CrossAccountId::from_eth(caller);11761177 let budget = self1178 .recorder1179 .weight_calls_budget(<StructureWeight<T>>::find_parent());11801181 let users = [(to, 1)]1182 .into_iter()1183 .collect::<BTreeMap<_, _>>()1184 .try_into()1185 .unwrap();1186 <Pallet<T>>::create_item(1187 self,1188 &caller,1189 CreateItemData::<T> { users, properties },1190 &budget,1191 )1192 .map_err(dispatch_to_evm::<T>)?;11931194 Ok(token_id.into())1195 }11961197 /// Returns EVM address for refungible token1198 ///1199 /// @param token ID of the token1200 fn token_contract_address(&self, token: U256) -> Result<Address> {1201 Ok(T::EvmTokenAddressMapping::token_to_address(1202 self.id,1203 token.try_into().map_err(|_| "token id overflow")?,1204 ))1205 }12061207 /// @notice Returns collection helper contract address1208 fn collection_helper_address(&self) -> Result<Address> {1209 Ok(T::ContractAddress::get())1210 }1211}12121213#[solidity_interface(1214 name = UniqueRefungible,1215 is(1216 ERC721,1217 ERC721Enumerable,1218 ERC721UniqueExtensions,1219 ERC721UniqueMintable,1220 ERC721Burnable,1221 ERC721Metadata(if(this.flags.erc721metadata)),1222 Collection(via(common_mut returns CollectionHandle<T>)),1223 TokenProperties,1224 ),1225 enum(derive(PreDispatch)),1226)]1227impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}12281229// Not a tests, but code generators1230generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1231generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);12321233impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1234where1235 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1236{1237 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1238 fn call(1239 self,1240 handle: &mut impl PrecompileHandle,1241 ) -> Option<pallet_common::erc::PrecompileResult> {1242 call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1243 }1244}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Refungible Pallet EVM API for tokens18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.2122extern crate alloc;2324use alloc::string::ToString;25use core::{26 char::{decode_utf16, REPLACEMENT_CHARACTER},27 convert::TryInto,28};2930use evm_coder::{abi::AbiType, generate_stubgen, solidity_interface, types::*, AbiCoder, ToLog};31use frame_support::{BoundedBTreeMap, BoundedVec};32use pallet_common::{33 erc::{static_property::key, CollectionCall, CommonEvmHandler},34 eth::{self, TokenUri},35 CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations, CommonWeightInfo,36 Error as CommonError,37};38use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm_coder_substrate::{40 call, dispatch_to_evm,41 execution::{Error, PreDispatch, Result},42 frontier_contract, SubstrateRecorder,43};44use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};45use sp_core::{Get, H160, U256};46use sp_std::{collections::btree_map::BTreeMap, vec, vec::Vec};47use up_data_structs::{48 budget::Budget, mapping::TokenAddressMapping, CollectionId, CollectionPropertiesVec, Property,49 PropertyKey, PropertyKeyPermission, PropertyPermission, TokenId, TokenOwnerError,50};5152use crate::{53 common::{mint_with_props_weight, CommonWeights},54 weights::WeightInfo,55 AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,56 TokenProperties, TokensMinted, TotalSupply,57};5859frontier_contract! {60 macro_rules! RefungibleHandle_result {...}61 impl<T: Config> Contract for RefungibleHandle<T> {...}62}6364pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);6566/// Rft events.67#[derive(ToLog)]68pub enum ERC721TokenEvent {69 /// The token has been changed.70 TokenChanged {71 /// Token ID.72 #[indexed]73 token_id: U256,74 },75}7677/// Token minting parameters78#[derive(AbiCoder, Default, Debug)]79pub struct OwnerPieces {80 /// Minted token owner81 pub owner: eth::CrossAddress,82 /// Number of token pieces83 pub pieces: u128,84}8586/// Token minting parameters87#[derive(AbiCoder, Default, Debug)]88pub struct MintTokenData {89 /// Minted token owner and number of pieces90 pub owners: Vec<OwnerPieces>,91 /// Minted token properties92 pub properties: Vec<eth::Property>,93}9495pub fn nesting_budget<T: Config>(recorder: &SubstrateRecorder<T>) -> impl Budget + '_ {96 recorder.weight_calls_budget(<StructureWeight<T>>::find_parent())97}9899/// @title A contract that allows to set and delete token properties and change token property permissions.100#[solidity_interface(name = TokenProperties, events(ERC721TokenEvent), enum(derive(PreDispatch)), enum_attr(weight))]101impl<T: Config> RefungibleHandle<T> {102 /// @notice Set permissions for token property.103 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.104 /// @param key Property key.105 /// @param isMutable Permission to mutate property.106 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.107 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.108 #[solidity(hide)]109 #[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]110 fn set_token_property_permission(111 &mut self,112 caller: Caller,113 key: String,114 is_mutable: bool,115 collection_admin: bool,116 token_owner: bool,117 ) -> Result<()> {118 let caller = T::CrossAccountId::from_eth(caller);119 <Pallet<T>>::set_token_property_permissions(120 self,121 &caller,122 vec![PropertyKeyPermission {123 key: <Vec<u8>>::from(key)124 .try_into()125 .map_err(|_| "too long key")?,126 permission: PropertyPermission {127 mutable: is_mutable,128 collection_admin,129 token_owner,130 },131 }],132 )133 .map_err(dispatch_to_evm::<T>)134 }135136 /// @notice Set permissions for token property.137 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.138 /// @param permissions Permissions for keys.139 #[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]140 fn set_token_property_permissions(141 &mut self,142 caller: Caller,143 permissions: Vec<eth::TokenPropertyPermission>,144 ) -> Result<()> {145 let caller = T::CrossAccountId::from_eth(caller);146 let perms = eth::TokenPropertyPermission::into_property_key_permissions(permissions)?;147148 <Pallet<T>>::set_token_property_permissions(self, &caller, perms)149 .map_err(dispatch_to_evm::<T>)150 }151152 /// @notice Get permissions for token properties.153 fn token_property_permissions(&self) -> Result<Vec<eth::TokenPropertyPermission>> {154 let perms = <Pallet<T>>::token_property_permission(self.id);155 Ok(perms156 .into_iter()157 .map(eth::TokenPropertyPermission::from)158 .collect())159 }160161 /// @notice Set token property value.162 /// @dev Throws error if `msg.sender` has no permission to edit the property.163 /// @param tokenId ID of the token.164 /// @param key Property key.165 /// @param value Property value.166 #[solidity(hide)]167 #[weight(<CommonWeights<T>>::set_token_properties(1))]168 fn set_property(169 &mut self,170 caller: Caller,171 token_id: U256,172 key: String,173 value: Bytes,174 ) -> Result<()> {175 let caller = T::CrossAccountId::from_eth(caller);176 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;177 let key = <Vec<u8>>::from(key)178 .try_into()179 .map_err(|_| "key too long")?;180 let value = value.0.try_into().map_err(|_| "value too long")?;181182 <Pallet<T>>::set_token_property(183 self,184 &caller,185 TokenId(token_id),186 Property { key, value },187 &nesting_budget(&self.recorder),188 )189 .map_err(dispatch_to_evm::<T>)190 }191192 /// @notice Set token properties value.193 /// @dev Throws error if `msg.sender` has no permission to edit the property.194 /// @param tokenId ID of the token.195 /// @param properties settable properties196 #[weight(<CommonWeights<T>>::set_token_properties(properties.len() as u32))]197 fn set_properties(198 &mut self,199 caller: Caller,200 token_id: U256,201 properties: Vec<eth::Property>,202 ) -> Result<()> {203 let caller = T::CrossAccountId::from_eth(caller);204 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;205206 let properties = properties207 .into_iter()208 .map(eth::Property::try_into)209 .collect::<Result<Vec<_>>>()?;210211 <Pallet<T>>::set_token_properties(212 self,213 &caller,214 TokenId(token_id),215 properties.into_iter(),216 &nesting_budget(&self.recorder),217 )218 .map_err(dispatch_to_evm::<T>)219 }220221 /// @notice Delete token property value.222 /// @dev Throws error if `msg.sender` has no permission to edit the property.223 /// @param tokenId ID of the token.224 /// @param key Property key.225 #[solidity(hide)]226 #[weight(<CommonWeights<T>>::delete_token_properties(1))]227 fn delete_property(&mut self, token_id: U256, caller: Caller, key: String) -> Result<()> {228 let caller = T::CrossAccountId::from_eth(caller);229 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;230 let key = <Vec<u8>>::from(key)231 .try_into()232 .map_err(|_| "key too long")?;233234 <Pallet<T>>::delete_token_property(235 self,236 &caller,237 TokenId(token_id),238 key,239 &nesting_budget(&self.recorder),240 )241 .map_err(dispatch_to_evm::<T>)242 }243244 /// @notice Delete token properties value.245 /// @dev Throws error if `msg.sender` has no permission to edit the property.246 /// @param tokenId ID of the token.247 /// @param keys Properties key.248 #[weight(<CommonWeights<T>>::delete_token_properties(keys.len() as u32))]249 fn delete_properties(250 &mut self,251 token_id: U256,252 caller: Caller,253 keys: Vec<String>,254 ) -> Result<()> {255 let caller = T::CrossAccountId::from_eth(caller);256 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;257 let keys = keys258 .into_iter()259 .map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))260 .collect::<Result<Vec<_>>>()?;261262 <Pallet<T>>::delete_token_properties(263 self,264 &caller,265 TokenId(token_id),266 keys.into_iter(),267 &nesting_budget(&self.recorder),268 )269 .map_err(dispatch_to_evm::<T>)270 }271272 /// @notice Get token property value.273 /// @dev Throws error if key not found274 /// @param tokenId ID of the token.275 /// @param key Property key.276 /// @return Property value bytes277 fn property(&self, token_id: U256, key: String) -> Result<Bytes> {278 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;279 let key = <Vec<u8>>::from(key)280 .try_into()281 .map_err(|_| "key too long")?;282283 let props =284 <TokenProperties<T>>::get((self.id, token_id)).ok_or("token properties not found")?;285 let prop = props.get(&key).ok_or("key not found")?;286287 Ok(prop.to_vec().into())288 }289}290291#[derive(ToLog)]292pub enum ERC721Events {293 /// @dev This event emits when NFTs are created (`from` == 0) and destroyed294 /// (`to` == 0). Exception: during contract creation, any number of RFTs295 /// may be created and assigned without emitting Transfer.296 Transfer {297 #[indexed]298 from: Address,299 #[indexed]300 to: Address,301 #[indexed]302 token_id: U256,303 },304 /// @dev Not supported305 Approval {306 #[indexed]307 owner: Address,308 #[indexed]309 approved: Address,310 #[indexed]311 token_id: U256,312 },313 /// @dev Not supported314 #[allow(dead_code)]315 ApprovalForAll {316 #[indexed]317 owner: Address,318 #[indexed]319 operator: Address,320 approved: bool,321 },322}323324/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension325/// @dev See https://eips.ethereum.org/EIPS/eip-721326#[solidity_interface(name = ERC721Metadata, enum(derive(PreDispatch)), expect_selector = 0x5b5e139f)]327impl<T: Config> RefungibleHandle<T>328where329 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,330{331 /// @notice A descriptive name for a collection of NFTs in this contract332 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`333 #[solidity(hide, rename_selector = "name")]334 fn name_proxy(&self) -> Result<String> {335 self.name()336 }337338 /// @notice An abbreviated name for NFTs in this contract339 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`340 #[solidity(hide, rename_selector = "symbol")]341 fn symbol_proxy(&self) -> Result<String> {342 self.symbol()343 }344345 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.346 ///347 /// @dev If the token has a `url` property and it is not empty, it is returned.348 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.349 /// If the collection property `baseURI` is empty or absent, return "" (empty string)350 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix351 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).352 ///353 /// @return token's const_metadata354 #[solidity(rename_selector = "tokenURI")]355 fn token_uri(&self, token_id: U256) -> Result<String> {356 let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;357358 match get_token_property(self, token_id_u32, &key::url()).as_deref() {359 Err(_) | Ok("") => (),360 Ok(url) => {361 return Ok(url.into());362 }363 };364365 let base_uri =366 pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())367 .map(BoundedVec::into_inner)368 .map(String::from_utf8)369 .transpose()370 .map_err(|e| {371 Error::Revert(alloc::format!(372 "can not convert value \"baseURI\" to string with error \"{e}\""373 ))374 })?;375376 let base_uri = match base_uri.as_deref() {377 None | Some("") => {378 return Ok("".into());379 }380 Some(base_uri) => base_uri.into(),381 };382383 Ok(384 match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {385 Err(_) | Ok("") => base_uri,386 Ok(suffix) => base_uri + suffix,387 },388 )389 }390}391392/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension393/// @dev See https://eips.ethereum.org/EIPS/eip-721394#[solidity_interface(name = ERC721Enumerable, enum(derive(PreDispatch)), expect_selector = 0x780e9d63)]395impl<T: Config> RefungibleHandle<T> {396 /// @notice Enumerate valid RFTs397 /// @param index A counter less than `totalSupply()`398 /// @return The token identifier for the `index`th NFT,399 /// (sort order not specified)400 fn token_by_index(&self, index: U256) -> U256 {401 index402 }403404 /// Not implemented405 fn token_of_owner_by_index(&self, _owner: Address, _index: U256) -> Result<U256> {406 // TODO: Not implemetable407 Err("not implemented".into())408 }409410 /// @notice Count RFTs tracked by this contract411 /// @return A count of valid RFTs tracked by this contract, where each one of412 /// them has an assigned and queryable owner not equal to the zero address413 fn total_supply(&self) -> Result<U256> {414 self.consume_store_reads(1)?;415 Ok(<Pallet<T>>::total_supply(self).into())416 }417}418419/// @title ERC-721 Non-Fungible Token Standard420/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md421#[solidity_interface(name = ERC721, events(ERC721Events), enum(derive(PreDispatch)), enum_attr(weight), expect_selector = 0x80ac58cd)]422impl<T: Config> RefungibleHandle<T> {423 /// @notice Count all RFTs assigned to an owner424 /// @dev RFTs assigned to the zero address are considered invalid, and this425 /// function throws for queries about the zero address.426 /// @param owner An address for whom to query the balance427 /// @return The number of RFTs owned by `owner`, possibly zero428 fn balance_of(&self, owner: Address) -> Result<U256> {429 self.consume_store_reads(1)?;430 let owner = T::CrossAccountId::from_eth(owner);431 let balance = <AccountBalance<T>>::get((self.id, owner));432 Ok(balance.into())433 }434435 /// @notice Find the owner of an RFT436 /// @dev RFTs assigned to zero address are considered invalid, and queries437 /// about them do throw.438 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for439 /// the tokens that are partially owned.440 /// @param tokenId The identifier for an RFT441 /// @return The address of the owner of the RFT442 fn owner_of(&self, token_id: U256) -> Result<Address> {443 self.consume_store_reads(2)?;444 let token = token_id.try_into()?;445 let owner = <Pallet<T>>::token_owner(self.id, token);446 owner447 .map(|address| *address.as_eth())448 .or_else(|err| match err {449 TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),450 TokenOwnerError::MultipleOwners => Ok(ADDRESS_FOR_PARTIALLY_OWNED_TOKENS),451 })452 }453454 /// @dev Not implemented455 #[solidity(rename_selector = "safeTransferFrom")]456 fn safe_transfer_from_with_data(457 &mut self,458 _from: Address,459 _to: Address,460 _token_id: U256,461 _data: Bytes,462 ) -> Result<()> {463 // TODO: Not implemetable464 Err("not implemented".into())465 }466467 /// @dev Not implemented468 #[solidity(rename_selector = "safeTransferFrom")]469 fn safe_transfer_from(&mut self, _from: Address, _to: Address, _token_id: U256) -> Result<()> {470 // TODO: Not implemetable471 Err("not implemented".into())472 }473474 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE475 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE476 /// THEY MAY BE PERMANENTLY LOST477 /// @dev Throws unless `msg.sender` is the current owner or an authorized478 /// operator for this RFT. Throws if `from` is not the current owner. Throws479 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.480 /// Throws if RFT pieces have multiple owners.481 /// @param from The current owner of the NFT482 /// @param to The new owner483 /// @param tokenId The NFT to transfer484 #[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]485 fn transfer_from(486 &mut self,487 caller: Caller,488 from: Address,489 to: Address,490 token_id: U256,491 ) -> Result<()> {492 let caller = T::CrossAccountId::from_eth(caller);493 let from = T::CrossAccountId::from_eth(from);494 let to = T::CrossAccountId::from_eth(to);495 let token = token_id.try_into()?;496497 let balance = balance(self, token, &from)?;498 ensure_single_owner(self, token, balance)?;499500 <Pallet<T>>::transfer_from(501 self,502 &caller,503 &from,504 &to,505 token,506 balance,507 &nesting_budget(&self.recorder),508 )509 .map_err(dispatch_to_evm::<T>)?;510511 Ok(())512 }513514 /// @dev Not implemented515 fn approve(&mut self, _caller: Caller, _approved: Address, _token_id: U256) -> Result<()> {516 Err("not implemented".into())517 }518519 /// @notice Sets or unsets the approval of a given operator.520 /// The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.521 /// @param operator Operator522 /// @param approved Should operator status be granted or revoked?523 #[weight(<SelfWeightOf<T>>::set_allowance_for_all())]524 fn set_approval_for_all(525 &mut self,526 caller: Caller,527 operator: Address,528 approved: bool,529 ) -> Result<()> {530 let caller = T::CrossAccountId::from_eth(caller);531 let operator = T::CrossAccountId::from_eth(operator);532533 <Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)534 .map_err(dispatch_to_evm::<T>)?;535 Ok(())536 }537538 /// @dev Not implemented539 fn get_approved(&self, _token_id: U256) -> Result<Address> {540 // TODO: Not implemetable541 Err("not implemented".into())542 }543544 /// @notice Tells whether the given `owner` approves the `operator`.545 #[weight(<SelfWeightOf<T>>::allowance_for_all())]546 fn is_approved_for_all(&self, owner: Address, operator: Address) -> Result<bool> {547 let owner = T::CrossAccountId::from_eth(owner);548 let operator = T::CrossAccountId::from_eth(operator);549550 Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))551 }552}553554/// Returns amount of pieces of `token` that `owner` have555pub fn balance<T: Config>(556 collection: &RefungibleHandle<T>,557 token: TokenId,558 owner: &T::CrossAccountId,559) -> Result<u128> {560 collection.consume_store_reads(1)?;561 let balance = <Balance<T>>::get((collection.id, token, &owner));562 Ok(balance)563}564565/// Throws if `owner_balance` is lower than total amount of `token` pieces566pub fn ensure_single_owner<T: Config>(567 collection: &RefungibleHandle<T>,568 token: TokenId,569 owner_balance: u128,570) -> Result<()> {571 collection.consume_store_reads(1)?;572 let total_supply = <TotalSupply<T>>::get((collection.id, token));573574 if owner_balance == 0 {575 return Err(dispatch_to_evm::<T>(576 <CommonError<T>>::MustBeTokenOwner.into(),577 ));578 }579580 if total_supply != owner_balance {581 return Err("token has multiple owners".into());582 }583 Ok(())584}585586/// @title ERC721 Token that can be irreversibly burned (destroyed).587#[solidity_interface(name = ERC721Burnable, enum(derive(PreDispatch)), enum_attr(weight))]588impl<T: Config> RefungibleHandle<T> {589 /// @notice Burns a specific ERC721 token.590 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized591 /// operator of the current owner.592 /// @param tokenId The RFT to approve593 #[weight(<SelfWeightOf<T>>::burn_item_fully())]594 fn burn(&mut self, caller: Caller, token_id: U256) -> Result<()> {595 let caller = T::CrossAccountId::from_eth(caller);596 let token = token_id.try_into()?;597598 let balance = balance(self, token, &caller)?;599 ensure_single_owner(self, token, balance)?;600601 <Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;602 Ok(())603 }604}605606/// @title ERC721 minting logic.607#[solidity_interface(name = ERC721UniqueMintable, enum(derive(PreDispatch)), enum_attr(weight))]608impl<T: Config> RefungibleHandle<T> {609 /// @notice Function to mint a token.610 /// @param to The new owner611 /// @return uint256 The id of the newly minted token612 #[weight(<SelfWeightOf<T>>::create_item())]613 fn mint(&mut self, caller: Caller, to: Address) -> Result<U256> {614 let token_id: U256 = <TokensMinted<T>>::get(self.id)615 .checked_add(1)616 .ok_or("item id overflow")?617 .into();618 self.mint_check_id(caller, to, token_id)?;619 Ok(token_id)620 }621622 /// @notice Function to mint a token.623 /// @dev `tokenId` should be obtained with `nextTokenId` method,624 /// unlike standard, you can't specify it manually625 /// @param to The new owner626 /// @param tokenId ID of the minted RFT627 #[solidity(hide, rename_selector = "mint")]628 #[weight(<SelfWeightOf<T>>::create_item())]629 fn mint_check_id(&mut self, caller: Caller, to: Address, token_id: U256) -> Result<bool> {630 let caller = T::CrossAccountId::from_eth(caller);631 let to = T::CrossAccountId::from_eth(to);632 let token_id: u32 = token_id.try_into()?;633634 if <TokensMinted<T>>::get(self.id)635 .checked_add(1)636 .ok_or("item id overflow")?637 != token_id638 {639 return Err("item id should be next".into());640 }641642 let users = [(to, 1)]643 .into_iter()644 .collect::<BTreeMap<_, _>>()645 .try_into()646 .unwrap();647 <Pallet<T>>::create_item(648 self,649 &caller,650 CreateItemData::<T> {651 users,652 properties: CollectionPropertiesVec::default(),653 },654 &nesting_budget(&self.recorder),655 )656 .map_err(dispatch_to_evm::<T>)?;657658 Ok(true)659 }660661 /// @notice Function to mint token with the given tokenUri.662 /// @param to The new owner663 /// @param tokenUri Token URI that would be stored in the NFT properties664 /// @return uint256 The id of the newly minted token665 #[solidity(rename_selector = "mintWithTokenURI")]666 #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]667 fn mint_with_token_uri(668 &mut self,669 caller: Caller,670 to: Address,671 token_uri: String,672 ) -> Result<U256> {673 let token_id: U256 = <TokensMinted<T>>::get(self.id)674 .checked_add(1)675 .ok_or("item id overflow")?676 .into();677 self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;678 Ok(token_id)679 }680681 /// @notice Function to mint token with the given tokenUri.682 /// @dev `tokenId` should be obtained with `nextTokenId` method,683 /// unlike standard, you can't specify it manually684 /// @param to The new owner685 /// @param tokenId ID of the minted RFT686 /// @param tokenUri Token URI that would be stored in the RFT properties687 #[solidity(hide, rename_selector = "mintWithTokenURI")]688 #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [1].into_iter()))]689 fn mint_with_token_uri_check_id(690 &mut self,691 caller: Caller,692 to: Address,693 token_id: U256,694 token_uri: String,695 ) -> Result<bool> {696 let key = key::url();697 let permission = get_token_permission::<T>(self.id, &key)?;698 if !permission.collection_admin {699 return Err("operation is not allowed".into());700 }701702 let caller = T::CrossAccountId::from_eth(caller);703 let to = T::CrossAccountId::from_eth(to);704 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;705706 if <TokensMinted<T>>::get(self.id)707 .checked_add(1)708 .ok_or("item id overflow")?709 != token_id710 {711 return Err("item id should be next".into());712 }713714 let mut properties = CollectionPropertiesVec::default();715 properties716 .try_push(Property {717 key,718 value: token_uri719 .into_bytes()720 .try_into()721 .map_err(|_| "token uri is too long")?,722 })723 .map_err(|e| Error::Revert(alloc::format!("can't add property: {e:?}")))?;724725 let users = [(to, 1)]726 .into_iter()727 .collect::<BTreeMap<_, _>>()728 .try_into()729 .unwrap();730 <Pallet<T>>::create_item(731 self,732 &caller,733 CreateItemData::<T> { users, properties },734 &nesting_budget(&self.recorder),735 )736 .map_err(dispatch_to_evm::<T>)?;737 Ok(true)738 }739}740741fn get_token_property<T: Config>(742 collection: &CollectionHandle<T>,743 token_id: u32,744 key: &up_data_structs::PropertyKey,745) -> Result<String> {746 collection.consume_store_reads(1)?;747 let properties = <TokenProperties<T>>::try_get((collection.id, token_id))748 .map_err(|_| Error::Revert("token properties not found".into()))?;749 if let Some(property) = properties.get(key) {750 return Ok(String::from_utf8_lossy(property).into());751 }752753 Err("property tokenURI not found".into())754}755756fn get_token_permission<T: Config>(757 collection_id: CollectionId,758 key: &PropertyKey,759) -> Result<PropertyPermission> {760 let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)761 .map_err(|_| Error::Revert("no permissions for collection".into()))?;762 let a = token_property_permissions763 .get(key)764 .map(Clone::clone)765 .ok_or_else(|| {766 let key = String::from_utf8(key.clone().into_inner()).unwrap_or_default();767 Error::Revert(alloc::format!("no permission for key {key}"))768 })?;769 Ok(a)770}771772/// @title Unique extensions for ERC721.773#[solidity_interface(name = ERC721UniqueExtensions, enum(derive(PreDispatch)), enum_attr(weight))]774impl<T: Config> RefungibleHandle<T>775where776 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,777{778 /// @notice A descriptive name for a collection of NFTs in this contract779 fn name(&self) -> Result<String> {780 Ok(decode_utf16(self.name.iter().copied())781 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))782 .collect::<String>())783 }784785 /// @notice An abbreviated name for NFTs in this contract786 fn symbol(&self) -> Result<String> {787 Ok(String::from_utf8_lossy(&self.token_prefix).into())788 }789790 /// @notice A description for the collection.791 fn description(&self) -> Result<String> {792 Ok(decode_utf16(self.description.iter().copied())793 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))794 .collect::<String>())795 }796797 /// Returns the owner (in cross format) of the token.798 ///799 /// @param tokenId Id for the token.800 #[solidity(hide)]801 fn cross_owner_of(&self, token_id: U256) -> Result<eth::CrossAddress> {802 Self::owner_of_cross(self, token_id)803 }804805 /// Returns the owner (in cross format) of the token.806 ///807 /// @param tokenId Id for the token.808 fn owner_of_cross(&self, token_id: U256) -> Result<eth::CrossAddress> {809 Self::token_owner(self, token_id.try_into()?)810 .map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))811 .or_else(|err| match err {812 TokenOwnerError::NotFound => Err(Error::Revert("token not found".into())),813 TokenOwnerError::MultipleOwners => Ok(eth::CrossAddress::from_eth(814 ADDRESS_FOR_PARTIALLY_OWNED_TOKENS,815 )),816 })817 }818819 /// @notice Count all RFTs assigned to an owner820 /// @param owner An cross address for whom to query the balance821 /// @return The number of RFTs owned by `owner`, possibly zero822 fn balance_of_cross(&self, owner: eth::CrossAddress) -> Result<U256> {823 self.consume_store_reads(1)?;824 let balance = <AccountBalance<T>>::get((self.id, owner.into_sub_cross_account::<T>()?));825 Ok(balance.into())826 }827828 /// Returns the token properties.829 ///830 /// @param tokenId Id for the token.831 /// @param keys Properties keys. Empty keys for all propertyes.832 /// @return Vector of properties key/value pairs.833 fn properties(&self, token_id: U256, keys: Vec<String>) -> Result<Vec<eth::Property>> {834 let keys = keys835 .into_iter()836 .map(|key| {837 <Vec<u8>>::from(key)838 .try_into()839 .map_err(|_| Error::Revert("key too large".into()))840 })841 .collect::<Result<Vec<_>>>()?;842843 <Self as CommonCollectionOperations<T>>::token_properties(844 self,845 token_id.try_into()?,846 if keys.is_empty() { None } else { Some(keys) },847 )848 .into_iter()849 .map(eth::Property::try_from)850 .collect::<Result<Vec<_>>>()851 }852 /// @notice Transfer ownership of an RFT853 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`854 /// is the zero address. Throws if `tokenId` is not a valid RFT.855 /// Throws if RFT pieces have multiple owners.856 /// @param to The new owner857 /// @param tokenId The RFT to transfer858 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]859 fn transfer(&mut self, caller: Caller, to: Address, token_id: U256) -> Result<()> {860 let caller = T::CrossAccountId::from_eth(caller);861 let to = T::CrossAccountId::from_eth(to);862 let token = token_id.try_into()?;863864 let balance = balance(self, token, &caller)?;865 ensure_single_owner(self, token, balance)?;866867 <Pallet<T>>::transfer(868 self,869 &caller,870 &to,871 token,872 balance,873 &nesting_budget(&self.recorder),874 )875 .map_err(dispatch_to_evm::<T>)?;876 Ok(())877 }878879 /// @notice Transfer ownership of an RFT880 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`881 /// is the zero address. Throws if `tokenId` is not a valid RFT.882 /// Throws if RFT pieces have multiple owners.883 /// @param to The new owner884 /// @param tokenId The RFT to transfer885 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]886 fn transfer_cross(887 &mut self,888 caller: Caller,889 to: eth::CrossAddress,890 token_id: U256,891 ) -> Result<()> {892 let caller = T::CrossAccountId::from_eth(caller);893 let to = to.into_sub_cross_account::<T>()?;894 let token = token_id.try_into()?;895896 let balance = balance(self, token, &caller)?;897 ensure_single_owner(self, token, balance)?;898899 <Pallet<T>>::transfer(900 self,901 &caller,902 &to,903 token,904 balance,905 &nesting_budget(&self.recorder),906 )907 .map_err(dispatch_to_evm::<T>)?;908 Ok(())909 }910911 /// @notice Transfer ownership of an RFT912 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`913 /// is the zero address. Throws if `tokenId` is not a valid RFT.914 /// Throws if RFT pieces have multiple owners.915 /// @param to The new owner916 /// @param tokenId The RFT to transfer917 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]918 fn transfer_from_cross(919 &mut self,920 caller: Caller,921 from: eth::CrossAddress,922 to: eth::CrossAddress,923 token_id: U256,924 ) -> Result<()> {925 let caller = T::CrossAccountId::from_eth(caller);926 let from = from.into_sub_cross_account::<T>()?;927 let to = to.into_sub_cross_account::<T>()?;928 let token_id = token_id.try_into()?;929930 let balance = balance(self, token_id, &from)?;931 ensure_single_owner(self, token_id, balance)?;932933 Pallet::<T>::transfer_from(934 self,935 &caller,936 &from,937 &to,938 token_id,939 balance,940 &nesting_budget(&self.recorder),941 )942 .map_err(dispatch_to_evm::<T>)?;943 Ok(())944 }945946 /// @notice Burns a specific ERC721 token.947 /// @dev Throws unless `msg.sender` is the current owner or an authorized948 /// operator for this RFT. Throws if `from` is not the current owner. Throws949 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.950 /// Throws if RFT pieces have multiple owners.951 /// @param from The current owner of the RFT952 /// @param tokenId The RFT to transfer953 #[solidity(hide)]954 #[weight(<SelfWeightOf<T>>::burn_from())]955 fn burn_from(&mut self, caller: Caller, from: Address, token_id: U256) -> Result<()> {956 let caller = T::CrossAccountId::from_eth(caller);957 let from = T::CrossAccountId::from_eth(from);958 let token = token_id.try_into()?;959960 let balance = balance(self, token, &from)?;961 ensure_single_owner(self, token, balance)?;962963 <Pallet<T>>::burn_from(964 self,965 &caller,966 &from,967 token,968 balance,969 &nesting_budget(&self.recorder),970 )971 .map_err(dispatch_to_evm::<T>)?;972 Ok(())973 }974975 /// @notice Burns a specific ERC721 token.976 /// @dev Throws unless `msg.sender` is the current owner or an authorized977 /// operator for this RFT. Throws if `from` is not the current owner. Throws978 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.979 /// Throws if RFT pieces have multiple owners.980 /// @param from The current owner of the RFT981 /// @param tokenId The RFT to transfer982 #[weight(<SelfWeightOf<T>>::burn_from())]983 fn burn_from_cross(984 &mut self,985 caller: Caller,986 from: eth::CrossAddress,987 token_id: U256,988 ) -> Result<()> {989 let caller = T::CrossAccountId::from_eth(caller);990 let from = from.into_sub_cross_account::<T>()?;991 let token = token_id.try_into()?;992993 let balance = balance(self, token, &from)?;994 ensure_single_owner(self, token, balance)?;995996 <Pallet<T>>::burn_from(997 self,998 &caller,999 &from,1000 token,1001 balance,1002 &nesting_budget(&self.recorder),1003 )1004 .map_err(dispatch_to_evm::<T>)?;1005 Ok(())1006 }10071008 /// @notice Returns next free RFT ID.1009 fn next_token_id(&self) -> Result<U256> {1010 self.consume_store_reads(1)?;1011 Ok(<Pallet<T>>::next_token_id(self)1012 .map_err(dispatch_to_evm::<T>)?1013 .into())1014 }10151016 /// @notice Function to mint multiple tokens.1017 /// @dev `tokenIds` should be an array of consecutive numbers and first number1018 /// should be obtained with `nextTokenId` method1019 /// @param to The new owner1020 /// @param tokenIds IDs of the minted RFTs1021 #[solidity(hide)]1022 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]1023 fn mint_bulk(&mut self, caller: Caller, to: Address, token_ids: Vec<U256>) -> Result<bool> {1024 let caller = T::CrossAccountId::from_eth(caller);1025 let to = T::CrossAccountId::from_eth(to);1026 let mut expected_index = <TokensMinted<T>>::get(self.id)1027 .checked_add(1)1028 .ok_or("item id overflow")?;10291030 let total_tokens = token_ids.len();1031 for id in token_ids.into_iter() {1032 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1033 if id != expected_index {1034 return Err("item id should be next".into());1035 }1036 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1037 }1038 let users = [(to, 1)]1039 .into_iter()1040 .collect::<BTreeMap<_, _>>()1041 .try_into()1042 .unwrap();1043 let create_item_data = CreateItemData::<T> {1044 users,1045 properties: CollectionPropertiesVec::default(),1046 };1047 let data = (0..total_tokens)1048 .map(|_| create_item_data.clone())1049 .collect();10501051 <Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))1052 .map_err(dispatch_to_evm::<T>)?;1053 Ok(true)1054 }10551056 /// @notice Function to mint a token.1057 /// @param tokensData Data of minted token(s)1058 #[weight(if tokens_data.len() == 1 {1059 let token_data = tokens_data.first().unwrap();10601061 mint_with_props_weight::<T>(1062 <SelfWeightOf<T>>::create_multiple_items_ex_multiple_owners(token_data.owners.len() as u32),1063 [token_data.properties.len() as u32].into_iter(),1064 )1065 } else {1066 mint_with_props_weight::<T>(1067 <SelfWeightOf<T>>::create_multiple_items_ex_multiple_items(tokens_data.len() as u32),1068 tokens_data.iter().map(|d| d.properties.len() as u32),1069 )1070 })]1071 fn mint_bulk_cross(&mut self, caller: Caller, tokens_data: Vec<MintTokenData>) -> Result<bool> {1072 let caller = T::CrossAccountId::from_eth(caller);1073 let has_multiple_tokens = tokens_data.len() > 1;10741075 let mut create_rft_data = Vec::with_capacity(tokens_data.len());1076 for MintTokenData { owners, properties } in tokens_data {1077 let has_multiple_owners = owners.len() > 1;1078 if has_multiple_tokens & has_multiple_owners {1079 return Err(1080 "creation of multiple tokens supported only if they have single owner each"1081 .into(),1082 );1083 }1084 let users: BoundedBTreeMap<_, _, _> = owners1085 .into_iter()1086 .map(|data| Ok((data.owner.into_sub_cross_account::<T>()?, data.pieces)))1087 .collect::<Result<BTreeMap<_, _>>>()?1088 .try_into()1089 .map_err(|_| "too many users")?;1090 create_rft_data.push(CreateItemData::<T> {1091 properties: properties1092 .into_iter()1093 .map(|property| property.try_into())1094 .collect::<Result<Vec<_>>>()?1095 .try_into()1096 .map_err(|_| "too many properties")?,1097 users,1098 });1099 }11001101 <Pallet<T>>::create_multiple_items(1102 self,1103 &caller,1104 create_rft_data,1105 &nesting_budget(&self.recorder),1106 )1107 .map_err(dispatch_to_evm::<T>)?;1108 Ok(true)1109 }11101111 /// @notice Function to mint multiple tokens with the given tokenUris.1112 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1113 /// numbers and first number should be obtained with `nextTokenId` method1114 /// @param to The new owner1115 /// @param tokens array of pairs of token ID and token URI for minted tokens1116 #[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1117 #[weight(1118 mint_with_props_weight::<T>(1119 <SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32),1120 tokens.iter().map(|_| 1),1121 )1122 )]1123 fn mint_bulk_with_token_uri(1124 &mut self,1125 caller: Caller,1126 to: Address,1127 tokens: Vec<TokenUri>,1128 ) -> Result<bool> {1129 let key = key::url();1130 let caller = T::CrossAccountId::from_eth(caller);1131 let to = T::CrossAccountId::from_eth(to);1132 let mut expected_index = <TokensMinted<T>>::get(self.id)1133 .checked_add(1)1134 .ok_or("item id overflow")?;11351136 let mut data = Vec::with_capacity(tokens.len());1137 let users: BoundedBTreeMap<_, _, _> = [(to, 1)]1138 .into_iter()1139 .collect::<BTreeMap<_, _>>()1140 .try_into()1141 .unwrap();1142 for TokenUri { id, uri } in tokens {1143 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1144 if id != expected_index {1145 return Err("item id should be next".into());1146 }1147 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;11481149 let mut properties = CollectionPropertiesVec::default();1150 properties1151 .try_push(Property {1152 key: key.clone(),1153 value: uri1154 .into_bytes()1155 .try_into()1156 .map_err(|_| "token uri is too long")?,1157 })1158 .map_err(|e| Error::Revert(alloc::format!("can't add property: {e:?}")))?;11591160 let create_item_data = CreateItemData::<T> {1161 users: users.clone(),1162 properties,1163 };1164 data.push(create_item_data);1165 }11661167 <Pallet<T>>::create_multiple_items(self, &caller, data, &nesting_budget(&self.recorder))1168 .map_err(dispatch_to_evm::<T>)?;1169 Ok(true)1170 }11711172 /// @notice Function to mint a token.1173 /// @param to The new owner crossAccountId1174 /// @param properties Properties of minted token1175 /// @return uint256 The id of the newly minted token1176 #[weight(mint_with_props_weight::<T>(<SelfWeightOf<T>>::create_item(), [properties.len() as u32].into_iter()))]1177 fn mint_cross(1178 &mut self,1179 caller: Caller,1180 to: eth::CrossAddress,1181 properties: Vec<eth::Property>,1182 ) -> Result<U256> {1183 let token_id = <TokensMinted<T>>::get(self.id)1184 .checked_add(1)1185 .ok_or("item id overflow")?;11861187 let to = to.into_sub_cross_account::<T>()?;11881189 let properties = properties1190 .into_iter()1191 .map(eth::Property::try_into)1192 .collect::<Result<Vec<_>>>()?1193 .try_into()1194 .map_err(|_| Error::Revert("too many properties".to_string()))?;11951196 let caller = T::CrossAccountId::from_eth(caller);11971198 let users = [(to, 1)]1199 .into_iter()1200 .collect::<BTreeMap<_, _>>()1201 .try_into()1202 .unwrap();1203 <Pallet<T>>::create_item(1204 self,1205 &caller,1206 CreateItemData::<T> { users, properties },1207 &nesting_budget(&self.recorder),1208 )1209 .map_err(dispatch_to_evm::<T>)?;12101211 Ok(token_id.into())1212 }12131214 /// Returns EVM address for refungible token1215 ///1216 /// @param token ID of the token1217 fn token_contract_address(&self, token: U256) -> Result<Address> {1218 Ok(T::EvmTokenAddressMapping::token_to_address(1219 self.id,1220 token.try_into().map_err(|_| "token id overflow")?,1221 ))1222 }12231224 /// @notice Returns collection helper contract address1225 fn collection_helper_address(&self) -> Result<Address> {1226 Ok(T::ContractAddress::get())1227 }1228}12291230#[solidity_interface(1231 name = UniqueRefungible,1232 is(1233 ERC721,1234 ERC721Enumerable,1235 ERC721UniqueExtensions,1236 ERC721UniqueMintable,1237 ERC721Burnable,1238 ERC721Metadata(if(this.flags.erc721metadata)),1239 Collection(via(common_mut returns CollectionHandle<T>)),1240 TokenProperties,1241 ),1242 enum(derive(PreDispatch)),1243)]1244impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}12451246// Not a tests, but code generators1247generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1248generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);12491250impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1251where1252 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1253{1254 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1255 fn call(1256 self,1257 handle: &mut impl PrecompileHandle,1258 ) -> Option<pallet_common::erc::PrecompileResult> {1259 call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1260 }1261}pallets/refungible/src/erc_token.rsdiffbeforeafterboth--- a/pallets/refungible/src/erc_token.rs
+++ b/pallets/refungible/src/erc_token.rs
@@ -37,14 +37,13 @@
execution::{PreDispatch, Result},
frontier_contract, WithRecorder,
};
-use pallet_structure::{weights::WeightInfo as _, SelfWeightOf as StructureWeight};
use sp_core::U256;
use sp_std::vec::Vec;
use up_data_structs::TokenId;
use crate::{
- common::CommonWeights, weights::WeightInfo, Allowance, Balance, Config, Pallet,
- RefungibleHandle, SelfWeightOf, TotalSupply,
+ common::CommonWeights, erc::nesting_budget, weights::WeightInfo, Allowance, Balance, Config,
+ Pallet, RefungibleHandle, SelfWeightOf, TotalSupply,
};
/// Refungible token handle contains information about token's collection and id
@@ -140,12 +139,16 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::transfer(
+ self,
+ &caller,
+ &to,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -165,12 +168,17 @@
let from = T::CrossAccountId::from_eth(from);
let to = T::CrossAccountId::from_eth(to);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer_from(self, &caller, &from, &to, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -231,12 +239,16 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = T::CrossAccountId::from_eth(from);
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::burn_from(
+ self,
+ &caller,
+ &from,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -254,12 +266,16 @@
let caller = T::CrossAccountId::from_eth(caller);
let from = from.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::burn_from(self, &caller, &from, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::burn_from(
+ self,
+ &caller,
+ &from,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -315,12 +331,16 @@
let caller = T::CrossAccountId::from_eth(caller);
let to = to.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer(self, &caller, &to, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::transfer(
+ self,
+ &caller,
+ &to,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
@@ -340,12 +360,17 @@
let from = from.into_sub_cross_account::<T>()?;
let to = to.into_sub_cross_account::<T>()?;
let amount = amount.try_into().map_err(|_| "amount overflow")?;
- let budget = self
- .recorder
- .weight_calls_budget(<StructureWeight<T>>::find_parent());
- <Pallet<T>>::transfer_from(self, &caller, &from, &to, self.1, amount, &budget)
- .map_err(dispatch_to_evm::<T>)?;
+ <Pallet<T>>::transfer_from(
+ self,
+ &caller,
+ &from,
+ &to,
+ self.1,
+ amount,
+ &nesting_budget(&self.recorder),
+ )
+ .map_err(dispatch_to_evm::<T>)?;
Ok(true)
}
}
pallets/refungible/src/lib.rsdiffbeforeafterboth--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -507,7 +507,7 @@
nesting_budget: &dyn Budget,
) -> DispatchResult {
let mut property_writer =
- pallet_common::property_writer_for_existing_token(collection, sender);
+ pallet_common::ExistingTokenPropertyWriter::new(collection, sender);
property_writer.write_token_properties(
sender,
@@ -858,7 +858,7 @@
// =========
- let mut property_writer = pallet_common::property_writer_for_new_token(collection, sender);
+ let mut property_writer = pallet_common::NewTokenPropertyWriter::new(collection, sender);
with_transaction(|| {
for (i, data) in data.iter().enumerate() {
pallets/refungible/src/weights.rsdiffbeforeafterboth--- a/pallets/refungible/src/weights.rs
+++ b/pallets/refungible/src/weights.rs
@@ -3,13 +3,13 @@
//! Autogenerated weights for pallet_refungible
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-09-30, STEPS: `50`, REPEAT: `400`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-10-13, STEPS: `50`, REPEAT: `80`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `bench-host`, CPU: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`
-//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+//! HOSTNAME: `hearthstone`, CPU: `AMD Ryzen 9 7950X3D 16-Core Processor`
+//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
// Executed Command:
-// target/production/unique-collator
+// ./target/production/unique-collator
// benchmark
// pallet
// --pallet
@@ -20,7 +20,7 @@
// *
// --template=.maintain/frame-weight-template.hbs
// --steps=50
-// --repeat=400
+// --repeat=80
// --heap-pages=4096
// --output=./pallets/refungible/src/weights.rs
@@ -50,12 +50,10 @@
fn transfer_from_removing() -> Weight;
fn transfer_from_creating_removing() -> Weight;
fn burn_from() -> Weight;
+ fn load_token_properties() -> Weight;
+ fn write_token_properties(b: u32, ) -> Weight;
fn set_token_property_permissions(b: u32, ) -> Weight;
- fn set_token_properties(b: u32, ) -> Weight;
- fn init_token_properties(b: u32, ) -> Weight;
- fn delete_token_properties(b: u32, ) -> Weight;
fn repartition_item() -> Weight;
- fn token_owner() -> Weight;
fn set_allowance_for_all() -> Weight;
fn allowance_for_all() -> Weight;
fn repair_item() -> Weight;
@@ -64,435 +62,399 @@
/// Weights for pallet_refungible using the Substrate node and recommended hardware.
pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn create_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3530`
- // Minimum execution time: 11_341_000 picoseconds.
- Weight::from_parts(11_741_000, 3530)
+ // Minimum execution time: 19_400_000 picoseconds.
+ Weight::from_parts(19_890_000, 3530)
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(5_u64))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:200)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:200)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3530`
- // Minimum execution time: 2_665_000 picoseconds.
- Weight::from_parts(2_791_000, 3530)
- // Standard Error: 996
- .saturating_add(Weight::from_parts(4_343_736, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_120_000 picoseconds.
+ Weight::from_parts(3_310_000, 3530)
+ // Standard Error: 2_748
+ .saturating_add(Weight::from_parts(11_489_631, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(2_u64))
.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:200 w:200)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:200)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:200)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 2_616_000 picoseconds.
- Weight::from_parts(2_726_000, 3481)
- // Standard Error: 665
- .saturating_add(Weight::from_parts(5_554_066, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_180_000 picoseconds.
+ Weight::from_parts(2_015_490, 3481)
+ // Standard Error: 6_052
+ .saturating_add(Weight::from_parts(14_837_077, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(T::DbWeight::get().writes(1_u64))
.saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:200 w:200)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 3_697_000 picoseconds.
- Weight::from_parts(2_136_481, 3481)
- // Standard Error: 567
- .saturating_add(Weight::from_parts(4_390_621, 0).saturating_mul(b.into()))
+ // Minimum execution time: 5_200_000 picoseconds.
+ Weight::from_parts(25_301_631, 3481)
+ // Standard Error: 6_177
+ .saturating_add(Weight::from_parts(11_197_931, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(T::DbWeight::get().writes(2_u64))
.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Refungible Balance (r:3 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:3 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn burn_item_partial() -> Weight {
// Proof Size summary in bytes:
// Measured: `456`
// Estimated: `8682`
- // Minimum execution time: 22_859_000 picoseconds.
- Weight::from_parts(23_295_000, 8682)
+ // Minimum execution time: 29_540_000 picoseconds.
+ Weight::from_parts(30_190_000, 8682)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TokensBurnt (r:1 w:1)
- /// Proof: Refungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Refungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_item_fully() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `3554`
- // Minimum execution time: 21_477_000 picoseconds.
- Weight::from_parts(22_037_000, 3554)
+ // Minimum execution time: 30_650_000 picoseconds.
+ Weight::from_parts(31_370_000, 3554)
.saturating_add(T::DbWeight::get().reads(4_u64))
.saturating_add(T::DbWeight::get().writes(6_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
fn transfer_normal() -> Weight {
// Proof Size summary in bytes:
// Measured: `365`
// Estimated: `6118`
- // Minimum execution time: 13_714_000 picoseconds.
- Weight::from_parts(14_050_000, 6118)
+ // Minimum execution time: 18_530_000 picoseconds.
+ Weight::from_parts(19_010_000, 6118)
.saturating_add(T::DbWeight::get().reads(3_u64))
.saturating_add(T::DbWeight::get().writes(2_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_creating() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `6118`
- // Minimum execution time: 15_879_000 picoseconds.
- Weight::from_parts(16_266_000, 6118)
+ // Minimum execution time: 24_240_000 picoseconds.
+ Weight::from_parts(24_760_000, 6118)
.saturating_add(T::DbWeight::get().reads(4_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `456`
// Estimated: `6118`
- // Minimum execution time: 18_186_000 picoseconds.
- Weight::from_parts(18_682_000, 6118)
+ // Minimum execution time: 25_990_000 picoseconds.
+ Weight::from_parts(26_650_000, 6118)
.saturating_add(T::DbWeight::get().reads(4_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:2 w:2)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:2)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:2)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_creating_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `6118`
- // Minimum execution time: 17_943_000 picoseconds.
- Weight::from_parts(18_333_000, 6118)
+ // Minimum execution time: 29_550_000 picoseconds.
+ Weight::from_parts(30_530_000, 6118)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(6_u64))
}
- /// Storage: Refungible Balance (r:1 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible Allowance (r:0 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:0)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Allowance` (r:0 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
fn approve() -> Weight {
// Proof Size summary in bytes:
// Measured: `223`
// Estimated: `3554`
- // Minimum execution time: 8_391_000 picoseconds.
- Weight::from_parts(8_637_000, 3554)
+ // Minimum execution time: 11_420_000 picoseconds.
+ Weight::from_parts(11_810_000, 3554)
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Refungible Balance (r:1 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible Allowance (r:0 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:0)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Allowance` (r:0 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
fn approve_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `211`
// Estimated: `3554`
- // Minimum execution time: 8_519_000 picoseconds.
- Weight::from_parts(8_760_000, 3554)
+ // Minimum execution time: 11_610_000 picoseconds.
+ Weight::from_parts(11_950_000, 3554)
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
fn transfer_from_normal() -> Weight {
// Proof Size summary in bytes:
// Measured: `495`
// Estimated: `6118`
- // Minimum execution time: 19_554_000 picoseconds.
- Weight::from_parts(20_031_000, 6118)
+ // Minimum execution time: 28_510_000 picoseconds.
+ Weight::from_parts(29_180_000, 6118)
.saturating_add(T::DbWeight::get().reads(4_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_creating() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `6118`
- // Minimum execution time: 21_338_000 picoseconds.
- Weight::from_parts(21_803_000, 6118)
+ // Minimum execution time: 34_370_000 picoseconds.
+ Weight::from_parts(35_270_000, 6118)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(5_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `586`
// Estimated: `6118`
- // Minimum execution time: 24_179_000 picoseconds.
- Weight::from_parts(24_647_000, 6118)
+ // Minimum execution time: 36_490_000 picoseconds.
+ Weight::from_parts(37_160_000, 6118)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(5_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:2 w:2)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:2)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:2)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_creating_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `6118`
- // Minimum execution time: 24_008_000 picoseconds.
- Weight::from_parts(24_545_000, 6118)
+ // Minimum execution time: 40_080_000 picoseconds.
+ Weight::from_parts(48_310_000, 6118)
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(7_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TokensBurnt (r:1 w:1)
- /// Proof: Refungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Refungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `3570`
- // Minimum execution time: 27_907_000 picoseconds.
- Weight::from_parts(28_489_000, 3570)
+ // Minimum execution time: 41_100_000 picoseconds.
+ Weight::from_parts(42_060_000, 3570)
.saturating_add(T::DbWeight::get().reads(5_u64))
.saturating_add(T::DbWeight::get().writes(7_u64))
- }
- /// Storage: Common CollectionPropertyPermissions (r:1 w:1)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_property_permissions(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `314`
- // Estimated: `20191`
- // Minimum execution time: 1_460_000 picoseconds.
- Weight::from_parts(1_564_000, 20191)
- // Standard Error: 14_117
- .saturating_add(Weight::from_parts(8_196_214, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(1_u64))
- .saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_properties(b: u32, ) -> Weight {
+ /// Storage: `Refungible::TokenProperties` (r:1 w:0)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
+ fn load_token_properties() -> Weight {
// Proof Size summary in bytes:
- // Measured: `502 + b * (261 ±0)`
+ // Measured: `120`
// Estimated: `36269`
- // Minimum execution time: 1_012_000 picoseconds.
- Weight::from_parts(1_081_000, 36269)
- // Standard Error: 6_838
- .saturating_add(Weight::from_parts(5_801_181, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(3_u64))
- .saturating_add(T::DbWeight::get().writes(1_u64))
+ // Minimum execution time: 2_520_000 picoseconds.
+ Weight::from_parts(2_670_000, 36269)
+ .saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn init_token_properties(b: u32, ) -> Weight {
+ fn write_token_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 229_000 picoseconds.
- Weight::from_parts(253_000, 0)
- // Standard Error: 100_218
- .saturating_add(Weight::from_parts(12_632_221, 0).saturating_mul(b.into()))
+ // Minimum execution time: 490_000 picoseconds.
+ Weight::from_parts(3_457_547, 0)
+ // Standard Error: 24_239
+ .saturating_add(Weight::from_parts(19_382_722, 0).saturating_mul(b.into()))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn delete_token_properties(b: u32, ) -> Weight {
+ fn set_token_property_permissions(b: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `561 + b * (33291 ±0)`
- // Estimated: `36269`
- // Minimum execution time: 1_014_000 picoseconds.
- Weight::from_parts(1_065_000, 36269)
- // Standard Error: 39_536
- .saturating_add(Weight::from_parts(24_125_838, 0).saturating_mul(b.into()))
- .saturating_add(T::DbWeight::get().reads(3_u64))
+ // Measured: `314`
+ // Estimated: `20191`
+ // Minimum execution time: 1_500_000 picoseconds.
+ Weight::from_parts(1_590_000, 20191)
+ // Standard Error: 123_927
+ .saturating_add(Weight::from_parts(27_355_093, 0).saturating_mul(b.into()))
+ .saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
fn repartition_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `288`
// Estimated: `3554`
- // Minimum execution time: 10_315_000 picoseconds.
- Weight::from_parts(10_601_000, 3554)
+ // Minimum execution time: 14_340_000 picoseconds.
+ Weight::from_parts(14_590_000, 3554)
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(2_u64))
- }
- /// Storage: Refungible Balance (r:2 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- fn token_owner() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `288`
- // Estimated: `6118`
- // Minimum execution time: 4_898_000 picoseconds.
- Weight::from_parts(5_136_000, 6118)
- .saturating_add(T::DbWeight::get().reads(2_u64))
}
- /// Storage: Refungible CollectionAllowance (r:0 w:1)
- /// Proof: Refungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Refungible::CollectionAllowance` (r:0 w:1)
+ /// Proof: `Refungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn set_allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_146_000 picoseconds.
- Weight::from_parts(4_337_000, 0)
+ // Minimum execution time: 6_390_000 picoseconds.
+ Weight::from_parts(6_650_000, 0)
.saturating_add(T::DbWeight::get().writes(1_u64))
}
- /// Storage: Refungible CollectionAllowance (r:1 w:0)
- /// Proof: Refungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Refungible::CollectionAllowance` (r:1 w:0)
+ /// Proof: `Refungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3576`
- // Minimum execution time: 2_170_000 picoseconds.
- Weight::from_parts(2_301_000, 3576)
+ // Minimum execution time: 3_060_000 picoseconds.
+ Weight::from_parts(3_210_000, 3576)
.saturating_add(T::DbWeight::get().reads(1_u64))
}
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokenProperties` (r:1 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn repair_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `120`
// Estimated: `36269`
- // Minimum execution time: 2_098_000 picoseconds.
- Weight::from_parts(2_251_000, 36269)
+ // Minimum execution time: 2_480_000 picoseconds.
+ Weight::from_parts(2_620_000, 36269)
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
}
@@ -500,435 +462,399 @@
// For backwards compatibility and tests
impl WeightInfo for () {
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn create_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3530`
- // Minimum execution time: 11_341_000 picoseconds.
- Weight::from_parts(11_741_000, 3530)
+ // Minimum execution time: 19_400_000 picoseconds.
+ Weight::from_parts(19_890_000, 3530)
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(5_u64))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:200)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:200)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3530`
- // Minimum execution time: 2_665_000 picoseconds.
- Weight::from_parts(2_791_000, 3530)
- // Standard Error: 996
- .saturating_add(Weight::from_parts(4_343_736, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_120_000 picoseconds.
+ Weight::from_parts(3_310_000, 3530)
+ // Standard Error: 2_748
+ .saturating_add(Weight::from_parts(11_489_631, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(2_u64))
.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:200 w:200)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:200)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:200)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex_multiple_items(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 2_616_000 picoseconds.
- Weight::from_parts(2_726_000, 3481)
- // Standard Error: 665
- .saturating_add(Weight::from_parts(5_554_066, 0).saturating_mul(b.into()))
+ // Minimum execution time: 3_180_000 picoseconds.
+ Weight::from_parts(2_015_490, 3481)
+ // Standard Error: 6_052
+ .saturating_add(Weight::from_parts(14_837_077, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(RocksDbWeight::get().writes(1_u64))
.saturating_add(RocksDbWeight::get().writes((4_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Refungible TokensMinted (r:1 w:1)
- /// Proof: Refungible TokensMinted (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:200 w:200)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:0 w:200)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:0 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:200)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokensMinted` (r:1 w:1)
+ /// Proof: `Refungible::TokensMinted` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:200 w:200)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:0 w:200)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:0 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:200)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 200]`.
fn create_multiple_items_ex_multiple_owners(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3481 + b * (2540 ±0)`
- // Minimum execution time: 3_697_000 picoseconds.
- Weight::from_parts(2_136_481, 3481)
- // Standard Error: 567
- .saturating_add(Weight::from_parts(4_390_621, 0).saturating_mul(b.into()))
+ // Minimum execution time: 5_200_000 picoseconds.
+ Weight::from_parts(25_301_631, 3481)
+ // Standard Error: 6_177
+ .saturating_add(Weight::from_parts(11_197_931, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(b.into())))
.saturating_add(RocksDbWeight::get().writes(2_u64))
.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))
.saturating_add(Weight::from_parts(0, 2540).saturating_mul(b.into()))
}
- /// Storage: Refungible Balance (r:3 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:3 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn burn_item_partial() -> Weight {
// Proof Size summary in bytes:
// Measured: `456`
// Estimated: `8682`
- // Minimum execution time: 22_859_000 picoseconds.
- Weight::from_parts(23_295_000, 8682)
+ // Minimum execution time: 29_540_000 picoseconds.
+ Weight::from_parts(30_190_000, 8682)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TokensBurnt (r:1 w:1)
- /// Proof: Refungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Refungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_item_fully() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `3554`
- // Minimum execution time: 21_477_000 picoseconds.
- Weight::from_parts(22_037_000, 3554)
+ // Minimum execution time: 30_650_000 picoseconds.
+ Weight::from_parts(31_370_000, 3554)
.saturating_add(RocksDbWeight::get().reads(4_u64))
.saturating_add(RocksDbWeight::get().writes(6_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
fn transfer_normal() -> Weight {
// Proof Size summary in bytes:
// Measured: `365`
// Estimated: `6118`
- // Minimum execution time: 13_714_000 picoseconds.
- Weight::from_parts(14_050_000, 6118)
+ // Minimum execution time: 18_530_000 picoseconds.
+ Weight::from_parts(19_010_000, 6118)
.saturating_add(RocksDbWeight::get().reads(3_u64))
.saturating_add(RocksDbWeight::get().writes(2_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_creating() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `6118`
- // Minimum execution time: 15_879_000 picoseconds.
- Weight::from_parts(16_266_000, 6118)
+ // Minimum execution time: 24_240_000 picoseconds.
+ Weight::from_parts(24_760_000, 6118)
.saturating_add(RocksDbWeight::get().reads(4_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `456`
// Estimated: `6118`
- // Minimum execution time: 18_186_000 picoseconds.
- Weight::from_parts(18_682_000, 6118)
+ // Minimum execution time: 25_990_000 picoseconds.
+ Weight::from_parts(26_650_000, 6118)
.saturating_add(RocksDbWeight::get().reads(4_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:2 w:2)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:2)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:2)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_creating_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `341`
// Estimated: `6118`
- // Minimum execution time: 17_943_000 picoseconds.
- Weight::from_parts(18_333_000, 6118)
+ // Minimum execution time: 29_550_000 picoseconds.
+ Weight::from_parts(30_530_000, 6118)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(6_u64))
}
- /// Storage: Refungible Balance (r:1 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible Allowance (r:0 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:0)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Allowance` (r:0 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
fn approve() -> Weight {
// Proof Size summary in bytes:
// Measured: `223`
// Estimated: `3554`
- // Minimum execution time: 8_391_000 picoseconds.
- Weight::from_parts(8_637_000, 3554)
+ // Minimum execution time: 11_420_000 picoseconds.
+ Weight::from_parts(11_810_000, 3554)
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Refungible Balance (r:1 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible Allowance (r:0 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Balance` (r:1 w:0)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Allowance` (r:0 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
fn approve_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `211`
// Estimated: `3554`
- // Minimum execution time: 8_519_000 picoseconds.
- Weight::from_parts(8_760_000, 3554)
+ // Minimum execution time: 11_610_000 picoseconds.
+ Weight::from_parts(11_950_000, 3554)
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
fn transfer_from_normal() -> Weight {
// Proof Size summary in bytes:
// Measured: `495`
// Estimated: `6118`
- // Minimum execution time: 19_554_000 picoseconds.
- Weight::from_parts(20_031_000, 6118)
+ // Minimum execution time: 28_510_000 picoseconds.
+ Weight::from_parts(29_180_000, 6118)
.saturating_add(RocksDbWeight::get().reads(4_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_creating() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `6118`
- // Minimum execution time: 21_338_000 picoseconds.
- Weight::from_parts(21_803_000, 6118)
+ // Minimum execution time: 34_370_000 picoseconds.
+ Weight::from_parts(35_270_000, 6118)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(5_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `586`
// Estimated: `6118`
- // Minimum execution time: 24_179_000 picoseconds.
- Weight::from_parts(24_647_000, 6118)
+ // Minimum execution time: 36_490_000 picoseconds.
+ Weight::from_parts(37_160_000, 6118)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(5_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:2 w:2)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:2 w:2)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:2)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:2 w:2)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:2 w:2)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:0)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:2)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
fn transfer_from_creating_removing() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `6118`
- // Minimum execution time: 24_008_000 picoseconds.
- Weight::from_parts(24_545_000, 6118)
+ // Minimum execution time: 40_080_000 picoseconds.
+ Weight::from_parts(48_310_000, 6118)
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(7_u64))
}
- /// Storage: Refungible Allowance (r:1 w:1)
- /// Proof: Refungible Allowance (max_values: None, max_size: Some(105), added: 2580, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible AccountBalance (r:1 w:1)
- /// Proof: Refungible AccountBalance (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
- /// Storage: Refungible TokensBurnt (r:1 w:1)
- /// Proof: Refungible TokensBurnt (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
- /// Storage: Refungible Owned (r:0 w:1)
- /// Proof: Refungible Owned (max_values: None, max_size: Some(74), added: 2549, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::Allowance` (r:1 w:1)
+ /// Proof: `Refungible::Allowance` (`max_values`: None, `max_size`: Some(105), added: 2580, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::AccountBalance` (r:1 w:1)
+ /// Proof: `Refungible::AccountBalance` (`max_values`: None, `max_size`: Some(65), added: 2540, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokensBurnt` (r:1 w:1)
+ /// Proof: `Refungible::TokensBurnt` (`max_values`: None, `max_size`: Some(16), added: 2491, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Owned` (r:0 w:1)
+ /// Proof: `Refungible::Owned` (`max_values`: None, `max_size`: Some(74), added: 2549, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn burn_from() -> Weight {
// Proof Size summary in bytes:
// Measured: `471`
// Estimated: `3570`
- // Minimum execution time: 27_907_000 picoseconds.
- Weight::from_parts(28_489_000, 3570)
+ // Minimum execution time: 41_100_000 picoseconds.
+ Weight::from_parts(42_060_000, 3570)
.saturating_add(RocksDbWeight::get().reads(5_u64))
.saturating_add(RocksDbWeight::get().writes(7_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:1)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_property_permissions(b: u32, ) -> Weight {
+ /// Storage: `Refungible::TokenProperties` (r:1 w:0)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
+ fn load_token_properties() -> Weight {
// Proof Size summary in bytes:
- // Measured: `314`
- // Estimated: `20191`
- // Minimum execution time: 1_460_000 picoseconds.
- Weight::from_parts(1_564_000, 20191)
- // Standard Error: 14_117
- .saturating_add(Weight::from_parts(8_196_214, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(1_u64))
- .saturating_add(RocksDbWeight::get().writes(1_u64))
- }
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// The range of component `b` is `[0, 64]`.
- fn set_token_properties(b: u32, ) -> Weight {
- // Proof Size summary in bytes:
- // Measured: `502 + b * (261 ±0)`
+ // Measured: `120`
// Estimated: `36269`
- // Minimum execution time: 1_012_000 picoseconds.
- Weight::from_parts(1_081_000, 36269)
- // Standard Error: 6_838
- .saturating_add(Weight::from_parts(5_801_181, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(3_u64))
- .saturating_add(RocksDbWeight::get().writes(1_u64))
+ // Minimum execution time: 2_520_000 picoseconds.
+ Weight::from_parts(2_670_000, 36269)
+ .saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Refungible TokenProperties (r:0 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokenProperties` (r:0 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn init_token_properties(b: u32, ) -> Weight {
+ fn write_token_properties(b: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 229_000 picoseconds.
- Weight::from_parts(253_000, 0)
- // Standard Error: 100_218
- .saturating_add(Weight::from_parts(12_632_221, 0).saturating_mul(b.into()))
+ // Minimum execution time: 490_000 picoseconds.
+ Weight::from_parts(3_457_547, 0)
+ // Standard Error: 24_239
+ .saturating_add(Weight::from_parts(19_382_722, 0).saturating_mul(b.into()))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Common CollectionPropertyPermissions (r:1 w:0)
- /// Proof: Common CollectionPropertyPermissions (max_values: None, max_size: Some(16726), added: 19201, mode: MaxEncodedLen)
- /// Storage: Refungible TotalSupply (r:1 w:0)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Common::CollectionPropertyPermissions` (r:1 w:1)
+ /// Proof: `Common::CollectionPropertyPermissions` (`max_values`: None, `max_size`: Some(16726), added: 19201, mode: `MaxEncodedLen`)
/// The range of component `b` is `[0, 64]`.
- fn delete_token_properties(b: u32, ) -> Weight {
+ fn set_token_property_permissions(b: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `561 + b * (33291 ±0)`
- // Estimated: `36269`
- // Minimum execution time: 1_014_000 picoseconds.
- Weight::from_parts(1_065_000, 36269)
- // Standard Error: 39_536
- .saturating_add(Weight::from_parts(24_125_838, 0).saturating_mul(b.into()))
- .saturating_add(RocksDbWeight::get().reads(3_u64))
+ // Measured: `314`
+ // Estimated: `20191`
+ // Minimum execution time: 1_500_000 picoseconds.
+ Weight::from_parts(1_590_000, 20191)
+ // Standard Error: 123_927
+ .saturating_add(Weight::from_parts(27_355_093, 0).saturating_mul(b.into()))
+ .saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Refungible TotalSupply (r:1 w:1)
- /// Proof: Refungible TotalSupply (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
- /// Storage: Refungible Balance (r:1 w:1)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TotalSupply` (r:1 w:1)
+ /// Proof: `Refungible::TotalSupply` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`)
+ /// Storage: `Refungible::Balance` (r:1 w:1)
+ /// Proof: `Refungible::Balance` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
fn repartition_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `288`
// Estimated: `3554`
- // Minimum execution time: 10_315_000 picoseconds.
- Weight::from_parts(10_601_000, 3554)
+ // Minimum execution time: 14_340_000 picoseconds.
+ Weight::from_parts(14_590_000, 3554)
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(2_u64))
}
- /// Storage: Refungible Balance (r:2 w:0)
- /// Proof: Refungible Balance (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
- fn token_owner() -> Weight {
- // Proof Size summary in bytes:
- // Measured: `288`
- // Estimated: `6118`
- // Minimum execution time: 4_898_000 picoseconds.
- Weight::from_parts(5_136_000, 6118)
- .saturating_add(RocksDbWeight::get().reads(2_u64))
- }
- /// Storage: Refungible CollectionAllowance (r:0 w:1)
- /// Proof: Refungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Refungible::CollectionAllowance` (r:0 w:1)
+ /// Proof: `Refungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn set_allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_146_000 picoseconds.
- Weight::from_parts(4_337_000, 0)
+ // Minimum execution time: 6_390_000 picoseconds.
+ Weight::from_parts(6_650_000, 0)
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
- /// Storage: Refungible CollectionAllowance (r:1 w:0)
- /// Proof: Refungible CollectionAllowance (max_values: None, max_size: Some(111), added: 2586, mode: MaxEncodedLen)
+ /// Storage: `Refungible::CollectionAllowance` (r:1 w:0)
+ /// Proof: `Refungible::CollectionAllowance` (`max_values`: None, `max_size`: Some(111), added: 2586, mode: `MaxEncodedLen`)
fn allowance_for_all() -> Weight {
// Proof Size summary in bytes:
// Measured: `4`
// Estimated: `3576`
- // Minimum execution time: 2_170_000 picoseconds.
- Weight::from_parts(2_301_000, 3576)
+ // Minimum execution time: 3_060_000 picoseconds.
+ Weight::from_parts(3_210_000, 3576)
.saturating_add(RocksDbWeight::get().reads(1_u64))
}
- /// Storage: Refungible TokenProperties (r:1 w:1)
- /// Proof: Refungible TokenProperties (max_values: None, max_size: Some(32804), added: 35279, mode: MaxEncodedLen)
+ /// Storage: `Refungible::TokenProperties` (r:1 w:1)
+ /// Proof: `Refungible::TokenProperties` (`max_values`: None, `max_size`: Some(32804), added: 35279, mode: `MaxEncodedLen`)
fn repair_item() -> Weight {
// Proof Size summary in bytes:
// Measured: `120`
// Estimated: `36269`
- // Minimum execution time: 2_098_000 picoseconds.
- Weight::from_parts(2_251_000, 36269)
+ // Minimum execution time: 2_480_000 picoseconds.
+ Weight::from_parts(2_620_000, 36269)
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
}
pallets/structure/src/lib.rsdiffbeforeafterboth--- a/pallets/structure/src/lib.rs
+++ b/pallets/structure/src/lib.rs
@@ -53,11 +53,7 @@
#![cfg_attr(not(feature = "std"), no_std)]
-use frame_support::{
- dispatch::{DispatchResult, DispatchResultWithPostInfo},
- fail,
- pallet_prelude::*,
-};
+use frame_support::{dispatch::DispatchResult, fail, pallet_prelude::*};
use pallet_common::{
dispatch::CollectionDispatch, erc::CrossAccountId, eth::is_collection,
CommonCollectionOperations,
@@ -267,22 +263,6 @@
}
Err(<Error<T>>::DepthLimit.into())
- }
-
- /// Burn token and all of it's nested tokens
- ///
- /// - `self_budget`: Limit for searching children in depth.
- /// - `breadth_budget`: Limit of breadth of searching children.
- pub fn burn_item_recursively(
- from: T::CrossAccountId,
- collection: CollectionId,
- token: TokenId,
- self_budget: &dyn Budget,
- breadth_budget: &dyn Budget,
- ) -> DispatchResultWithPostInfo {
- let dispatch = T::CollectionDispatch::dispatch(collection)?;
- let dispatch = dispatch.as_dyn();
- dispatch.burn_item_recursively(from, token, self_budget, breadth_budget)
}
/// Check if `token` indirectly owned by `user`
pallets/unique/Cargo.tomldiffbeforeafterboth--- a/pallets/unique/Cargo.toml
+++ b/pallets/unique/Cargo.toml
@@ -31,7 +31,9 @@
'parity-scale-codec/std',
'sp-runtime/std',
'sp-std/std',
+ 'up-common/std',
'up-data-structs/std',
+ 'pallet-structure/std',
]
stubgen = ["evm-coder/stubgen", "pallet-common/stubgen"]
try-runtime = ["frame-support/try-runtime"]
@@ -53,9 +55,11 @@
pallet-evm-coder-substrate = { workspace = true }
pallet-nonfungible = { workspace = true }
pallet-refungible = { workspace = true }
+pallet-structure = { workspace = true }
scale-info = { workspace = true }
sp-core = { workspace = true }
sp-io = { workspace = true }
sp-runtime = { workspace = true }
sp-std = { workspace = true }
+up-common = { workspace = true }
up-data-structs = { workspace = true }
pallets/unique/src/lib.rsdiffbeforeafterboth--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -84,13 +84,19 @@
#[frame_support::pallet]
pub mod pallet {
- use frame_support::{dispatch::DispatchResult, ensure, fail, storage::Key, BoundedVec};
+ use frame_support::{
+ dispatch::{DispatchErrorWithPostInfo, DispatchResult, PostDispatchInfo},
+ ensure, fail,
+ storage::Key,
+ BoundedVec,
+ };
use frame_system::{ensure_root, ensure_signed};
use pallet_common::{
dispatch::{dispatch_tx, CollectionDispatch},
CollectionHandle, CommonWeightInfo, Pallet as PalletCommon, RefungibleExtensionsWeightInfo,
};
use pallet_evm::account::CrossAccountId;
+ use pallet_structure::weights::WeightInfo as StructureWeightInfo;
use scale_info::TypeInfo;
use sp_std::{vec, vec::Vec};
use up_data_structs::{
@@ -104,9 +110,6 @@
use weights::WeightInfo;
use super::*;
-
- /// A maximum number of levels of depth in the token nesting tree.
- pub const NESTING_BUDGET: u32 = 5;
/// Errors for the common Unique transactions.
#[pallet::error]
@@ -128,6 +131,8 @@
/// Weight information for common pallet operations.
type CommonWeightInfo: CommonWeightInfo<Self::CrossAccountId>;
+ type StructureWeightInfo: StructureWeightInfo;
+
/// Weight info information for extra refungible pallet operations.
type RefungibleExtensionsWeightInfo: RefungibleExtensionsWeightInfo;
}
@@ -264,7 +269,7 @@
impl<T: Config> Pallet<T> {
/// A maximum number of levels of depth in the token nesting tree.
fn nesting_budget() -> u32 {
- NESTING_BUDGET
+ 5
}
/// Maximal length of a collection name.
@@ -666,7 +671,7 @@
/// * `owner`: Address of the initial owner of the item.
/// * `data`: Token data describing the item to store on chain.
#[pallet::call_index(11)]
- #[pallet::weight(T::CommonWeightInfo::create_item(data))]
+ #[pallet::weight(T::CommonWeightInfo::create_item(data) + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn create_item(
origin: OriginFor<T>,
collection_id: CollectionId,
@@ -674,11 +679,14 @@
data: CreateItemData,
) -> DispatchResultWithPostInfo {
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.create_item(sender, owner, data, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.create_item(sender, owner, data, &budget)
+ }),
+ budget,
+ )
}
/// Create multiple items within a collection.
@@ -700,7 +708,7 @@
/// * `owner`: Address of the initial owner of the tokens.
/// * `items_data`: Vector of data describing each item to be created.
#[pallet::call_index(12)]
- #[pallet::weight(T::CommonWeightInfo::create_multiple_items(items_data))]
+ #[pallet::weight(T::CommonWeightInfo::create_multiple_items(items_data) + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn create_multiple_items(
origin: OriginFor<T>,
collection_id: CollectionId,
@@ -709,11 +717,14 @@
) -> DispatchResultWithPostInfo {
ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.create_multiple_items(sender, owner, items_data, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.create_multiple_items(sender, owner, items_data, &budget)
+ }),
+ budget,
+ )
}
/// Add or change collection properties.
@@ -791,7 +802,7 @@
/// * `properties`: Vector of key-value pairs stored as the token's metadata.
/// Keys support Latin letters, `-`, `_`, and `.` as symbols.
#[pallet::call_index(15)]
- #[pallet::weight(T::CommonWeightInfo::set_token_properties(properties.len() as u32))]
+ #[pallet::weight(T::CommonWeightInfo::set_token_properties(properties.len() as u32) + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn set_token_properties(
origin: OriginFor<T>,
collection_id: CollectionId,
@@ -801,11 +812,14 @@
ensure!(!properties.is_empty(), Error::<T>::EmptyArgument);
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.set_token_properties(sender, token_id, properties, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.set_token_properties(sender, token_id, properties, &budget)
+ }),
+ budget,
+ )
}
/// Delete specified token properties. Currently properties only work with NFTs.
@@ -824,7 +838,7 @@
/// * `property_keys`: Vector of keys of the properties to be deleted.
/// Keys support Latin letters, `-`, `_`, and `.` as symbols.
#[pallet::call_index(16)]
- #[pallet::weight(T::CommonWeightInfo::delete_token_properties(property_keys.len() as u32))]
+ #[pallet::weight(T::CommonWeightInfo::delete_token_properties(property_keys.len() as u32) + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn delete_token_properties(
origin: OriginFor<T>,
collection_id: CollectionId,
@@ -834,11 +848,14 @@
ensure!(!property_keys.is_empty(), Error::<T>::EmptyArgument);
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.delete_token_properties(sender, token_id, property_keys, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.delete_token_properties(sender, token_id, property_keys, &budget)
+ }),
+ budget,
+ )
}
/// Add or change token property permissions of a collection.
@@ -888,18 +905,21 @@
/// * `collection_id`: ID of the collection to which the tokens would belong.
/// * `data`: Explicit item creation data.
#[pallet::call_index(18)]
- #[pallet::weight(T::CommonWeightInfo::create_multiple_items_ex(data))]
+ #[pallet::weight(T::CommonWeightInfo::create_multiple_items_ex(data) + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn create_multiple_items_ex(
origin: OriginFor<T>,
collection_id: CollectionId,
data: CreateItemExData<T::CrossAccountId>,
) -> DispatchResultWithPostInfo {
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.create_multiple_items_ex(sender, data, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.create_multiple_items_ex(sender, data, &budget)
+ }),
+ budget,
+ )
}
/// Completely allow or disallow transfers for a particular collection.
@@ -995,7 +1015,7 @@
/// * Fungible Mode: The desired number of pieces to burn.
/// * Re-Fungible Mode: The desired number of pieces to burn.
#[pallet::call_index(21)]
- #[pallet::weight(T::CommonWeightInfo::burn_from())]
+ #[pallet::weight(T::CommonWeightInfo::burn_from() + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn burn_from(
origin: OriginFor<T>,
collection_id: CollectionId,
@@ -1004,11 +1024,14 @@
value: u128,
) -> DispatchResultWithPostInfo {
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.burn_from(sender, from, item_id, value, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.burn_from(sender, from, item_id, value, &budget)
+ }),
+ budget,
+ )
}
/// Change ownership of the token.
@@ -1033,7 +1056,7 @@
/// * Fungible Mode: The desired number of pieces to transfer.
/// * Re-Fungible Mode: The desired number of pieces to transfer.
#[pallet::call_index(22)]
- #[pallet::weight(T::CommonWeightInfo::transfer())]
+ #[pallet::weight(T::CommonWeightInfo::transfer() + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn transfer(
origin: OriginFor<T>,
recipient: T::CrossAccountId,
@@ -1042,11 +1065,14 @@
value: u128,
) -> DispatchResultWithPostInfo {
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.transfer(sender, recipient, item_id, value, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.transfer(sender, recipient, item_id, value, &budget)
+ }),
+ budget,
+ )
}
/// Allow a non-permissioned address to transfer or burn an item.
@@ -1138,7 +1164,7 @@
/// * Fungible Mode: The desired number of pieces to transfer.
/// * Re-Fungible Mode: The desired number of pieces to transfer.
#[pallet::call_index(25)]
- #[pallet::weight(T::CommonWeightInfo::transfer_from())]
+ #[pallet::weight(T::CommonWeightInfo::transfer_from() + <Pallet<T>>::nesting_budget_predispatch_weight())]
pub fn transfer_from(
origin: OriginFor<T>,
from: T::CrossAccountId,
@@ -1148,11 +1174,14 @@
value: u128,
) -> DispatchResultWithPostInfo {
let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
- let budget = budget::Value::new(NESTING_BUDGET);
+ let budget = Self::structure_nesting_budget();
- dispatch_tx::<T, _>(collection_id, |d| {
- d.transfer_from(sender, from, recipient, item_id, value, &budget)
- })
+ Self::refund_nesting_budget(
+ dispatch_tx::<T, _>(collection_id, |d| {
+ d.transfer_from(sender, from, recipient, item_id, value, &budget)
+ }),
+ budget,
+ )
}
/// Set specific limits of a collection. Empty, or None fields mean chain default.
@@ -1348,5 +1377,40 @@
Ok(())
}
+
+ fn structure_nesting_budget() -> budget::Value {
+ budget::Value::new(Self::nesting_budget())
+ }
+
+ fn nesting_budget_predispatch_weight() -> Weight {
+ T::StructureWeightInfo::find_parent().saturating_mul(Self::nesting_budget() as u64)
+ }
+
+ pub fn refund_nesting_budget(
+ mut result: DispatchResultWithPostInfo,
+ budget: budget::Value,
+ ) -> DispatchResultWithPostInfo {
+ let refund_amount = budget.refund_amount();
+ let consumed = Self::nesting_budget() - refund_amount;
+
+ match &mut result {
+ Ok(PostDispatchInfo {
+ actual_weight: Some(weight),
+ ..
+ })
+ | Err(DispatchErrorWithPostInfo {
+ post_info: PostDispatchInfo {
+ actual_weight: Some(weight),
+ ..
+ },
+ ..
+ }) => {
+ *weight += T::StructureWeightInfo::find_parent().saturating_mul(consumed as u64)
+ }
+ _ => {}
+ }
+
+ result
+ }
}
}
primitives/common/src/constants.rsdiffbeforeafterboth--- a/primitives/common/src/constants.rs
+++ b/primitives/common/src/constants.rs
@@ -45,6 +45,7 @@
/// Minimum balance required to create or keep an account open.
pub const EXISTENTIAL_DEPOSIT: u128 = 0;
+
/// Amount of Balance reserved for candidate registration.
pub const GENESIS_LICENSE_BOND: u128 = 1_000_000_000_000 * UNIQUE;
/// Amount of maximum collators for Collator Selection.
primitives/data-structs/src/budget.rsdiffbeforeafterboth--- a/primitives/data-structs/src/budget.rs
+++ b/primitives/data-structs/src/budget.rs
@@ -1,4 +1,4 @@
-use core::cell::Cell;
+use sp_std::cell::Cell;
pub trait Budget {
/// Returns true while not exceeded
@@ -22,7 +22,7 @@
pub fn new(v: u32) -> Self {
Self(Cell::new(v))
}
- pub fn refund(self) -> u32 {
+ pub fn refund_amount(self) -> u32 {
self.0.get()
}
}
runtime/common/config/pallets/mod.rsdiffbeforeafterboth--- a/runtime/common/config/pallets/mod.rs
+++ b/runtime/common/config/pallets/mod.rs
@@ -116,6 +116,7 @@
impl pallet_unique::Config for Runtime {
type WeightInfo = pallet_unique::weights::SubstrateWeight<Self>;
type CommonWeightInfo = CommonWeights<Self>;
+ type StructureWeightInfo = pallet_structure::weights::SubstrateWeight<Self>;
type RefungibleExtensionsWeightInfo = CommonWeights<Self>;
}
runtime/common/runtime_apis.rsdiffbeforeafterboth--- a/runtime/common/runtime_apis.rs
+++ b/runtime/common/runtime_apis.rs
@@ -84,7 +84,7 @@
}
fn topmost_token_owner(collection: CollectionId, token: TokenId) -> Result<Option<CrossAccountId>, DispatchError> {
- let budget = up_data_structs::budget::Value::new(10);
+ let budget = budget::Value::new(10);
<pallet_structure::Pallet<Runtime>>::find_topmost_owner(collection, token, &budget)
}
runtime/common/weights/mod.rsdiffbeforeafterboth--- a/runtime/common/weights/mod.rs
+++ b/runtime/common/weights/mod.rs
@@ -98,10 +98,6 @@
dispatch_weight::<T>() + max_weight_of!(set_token_properties(amount))
}
- fn delete_token_properties(amount: u32) -> Weight {
- dispatch_weight::<T>() + max_weight_of!(delete_token_properties(amount))
- }
-
fn set_token_property_permissions(amount: u32) -> Weight {
dispatch_weight::<T>() + max_weight_of!(set_token_property_permissions(amount))
}
@@ -124,26 +120,14 @@
fn burn_from() -> Weight {
dispatch_weight::<T>() + max_weight_of!(burn_from())
- }
-
- fn burn_recursively_self_raw() -> Weight {
- max_weight_of!(burn_recursively_self_raw())
- }
-
- fn burn_recursively_breadth_raw(amount: u32) -> Weight {
- max_weight_of!(burn_recursively_breadth_raw(amount))
- }
-
- fn token_owner() -> Weight {
- max_weight_of!(token_owner())
}
fn set_allowance_for_all() -> Weight {
- max_weight_of!(set_allowance_for_all())
+ dispatch_weight::<T>() + max_weight_of!(set_allowance_for_all())
}
fn force_repair_item() -> Weight {
- max_weight_of!(force_repair_item())
+ dispatch_weight::<T>() + max_weight_of!(force_repair_item())
}
}
runtime/tests/src/lib.rsdiffbeforeafterboth--- a/runtime/tests/src/lib.rs
+++ b/runtime/tests/src/lib.rs
@@ -292,6 +292,7 @@
type WeightInfo = ();
type CommonWeightInfo = CommonWeights<Self>;
type RefungibleExtensionsWeightInfo = CommonWeights<Self>;
+ type StructureWeightInfo = pallet_structure::weights::SubstrateWeight<Self>;
}
// Build genesis storage according to the mock runtime.
runtime/tests/src/tests.rsdiffbeforeafterboth--- a/runtime/tests/src/tests.rs
+++ b/runtime/tests/src/tests.rs
@@ -2624,10 +2624,10 @@
use super::*;
- fn test<FTE: FnOnce() -> bool>(
+ fn test(
i: usize,
test_case: &pallet_common::tests::TestCase,
- check_token_existence: &mut LazyValue<bool, FTE>,
+ check_token_existence: &mut LazyValue<bool>,
) {
let collection_admin = test_case.collection_admin;
let mut is_collection_admin = LazyValue::new(|| test_case.is_collection_admin);
@@ -2635,7 +2635,7 @@
let mut is_token_owner = LazyValue::new(|| Ok(test_case.is_token_owner));
let is_no_permission = test_case.no_permission;
- let result = pallet_common::tests::check_token_permissions::<Test, _, _, FTE>(
+ let result = pallet_common::tests::check_token_permissions::<Test>(
collection_admin,
token_owner,
&mut is_collection_admin,
tests/src/eth/nativeFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/nativeFungible.test.ts
+++ b/tests/src/eth/nativeFungible.test.ts
@@ -33,7 +33,7 @@
const collectionAddress = helper.ethAddress.fromCollectionId(0);
const contract = await helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
- await expect(contract.methods.approve(spender, 100).call({from: owner})).to.be.rejectedWith('Approve not supported');
+ await expect(contract.methods.approve(spender, 100).call({from: owner})).to.be.rejectedWith('approve not supported');
});
itEth('balanceOf()', async ({helper}) => {
@@ -170,4 +170,4 @@
await expect(contract.methods.transferFromCross(receiver, receiver, 50).call({from: owner.eth})).to.be.rejectedWith('no permission');
});
-});
\ No newline at end of file
+});
tests/src/util/playgrounds/unique.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -3119,9 +3119,9 @@
async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {
const api = this.helper.getApi();
- const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON();
+ const props = (await api.query.nonfungible.tokenProperties(this.collectionId, tokenId)).toJSON() as any;
- return (props! as any).consumedSpace;
+ return props?.consumedSpace ?? 0;
}
async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId) {
@@ -3224,9 +3224,9 @@
async getTokenPropertiesConsumedSpace(tokenId: number): Promise<number> {
const api = this.helper.getApi();
- const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON();
+ const props = (await api.query.refungible.tokenProperties(this.collectionId, tokenId)).toJSON() as any;
- return (props! as any).consumedSpace;
+ return props?.consumedSpace ?? 0;
}
async transferToken(signer: TSigner, tokenId: number, addressObj: ICrossAccountId, amount = 1n) {