diff --git a/frame/support/src/lib.rs b/frame/support/src/lib.rs index c1aadc6fa57dc..57ab1d6febde7 100644 --- a/frame/support/src/lib.rs +++ b/frame/support/src/lib.rs @@ -76,7 +76,7 @@ pub use self::hash::{ pub use self::storage::{ StorageValue, StorageMap, StorageDoubleMap, StorageNMap, StoragePrefixedMap, IterableStorageMap, IterableStorageDoubleMap, IterableStorageNMap, migration, - bounded_vec::BoundedVec, weak_bounded_vec::WeakBoundedVec, + bounded_vec::{BoundedVec, BoundedSlice}, weak_bounded_vec::WeakBoundedVec, }; pub use self::dispatch::{Parameter, Callable}; pub use sp_runtime::{self, ConsensusEngineId, print, traits::Printable}; diff --git a/frame/support/src/storage/bounded_vec.rs b/frame/support/src/storage/bounded_vec.rs index 9575cb4bf4efb..d1c042b5db17f 100644 --- a/frame/support/src/storage/bounded_vec.rs +++ b/frame/support/src/storage/bounded_vec.rs @@ -20,7 +20,7 @@ use sp_std::prelude::*; use sp_std::{convert::TryFrom, fmt, marker::PhantomData}; -use codec::{Encode, Decode}; +use codec::{Encode, Decode, EncodeLike}; use core::{ ops::{Deref, Index, IndexMut}, slice::SliceIndex, @@ -40,6 +40,33 @@ use crate::{ #[derive(Encode)] pub struct BoundedVec(Vec, PhantomData); +/// A bounded slice. +/// +/// Similar to a `BoundedVec`, but not owned and cannot be decoded. +#[derive(Encode)] +pub struct BoundedSlice<'a, T, S>(&'a [T], PhantomData); + +// `BoundedSlice`s encode to something which will always decode into a `BoundedVec` or a `Vec`. +impl<'a, T: Encode + Decode, S: Get> EncodeLike> for BoundedSlice<'a, T, S> {} +impl<'a, T: Encode + Decode, S: Get> EncodeLike> for BoundedSlice<'a, T, S> {} + +impl<'a, T, S: Get> TryFrom<&'a [T]> for BoundedSlice<'a, T, S> { + type Error = (); + fn try_from(t: &'a [T]) -> Result { + if t.len() < S::get() as usize { + Ok(BoundedSlice(t, PhantomData)) + } else { + Err(()) + } + } +} + +impl<'a, T, S> From> for &'a [T] { + fn from(t: BoundedSlice<'a, T, S>) -> Self { + t.0 + } +} + impl> Decode for BoundedVec { fn decode(input: &mut I) -> Result { let inner = Vec::::decode(input)?; @@ -54,6 +81,9 @@ impl> Decode for BoundedVec { } } +// `BoundedVec`s encode to something which will always decode as a `Vec`. +impl> EncodeLike> for BoundedVec {} + impl BoundedVec { /// Create `Self` from `t` without any checks. fn unchecked_from(t: Vec) -> Self { diff --git a/frame/support/src/traits/tokens.rs b/frame/support/src/traits/tokens.rs index 82af5dbade8f7..ac316b82b03e5 100644 --- a/frame/support/src/traits/tokens.rs +++ b/frame/support/src/traits/tokens.rs @@ -21,6 +21,8 @@ pub mod fungible; pub mod fungibles; pub mod currency; pub mod imbalance; +pub mod nonfungible; +pub mod nonfungibles; mod misc; pub use misc::{ WithdrawConsequence, DepositConsequence, ExistenceRequirement, BalanceStatus, WithdrawReasons, diff --git a/frame/support/src/traits/tokens/nonfungible.rs b/frame/support/src/traits/tokens/nonfungible.rs new file mode 100644 index 0000000000000..348d830c5002d --- /dev/null +++ b/frame/support/src/traits/tokens/nonfungible.rs @@ -0,0 +1,190 @@ +// This file is part of Substrate. + +// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Traits for dealing with a single non-fungible asset class. +//! +//! This assumes a single level namespace identified by `Inspect::InstanceId`, and could +//! reasonably be implemented by pallets which wants to expose a single collection of NFT-like +//! objects. +//! +//! For an NFT API which has dual-level namespacing, the traits in `nonfungibles` are better to +//! use. + +use codec::{Encode, Decode}; +use sp_std::prelude::*; +use sp_runtime::TokenError; +use crate::dispatch::DispatchResult; +use crate::traits::Get; +use super::nonfungibles; + +/// Trait for providing an interface to a read-only NFT-like set of asset instances. +pub trait Inspect { + /// Type for identifying an asset instance. + type InstanceId; + + /// Returns the owner of asset `instance`, or `None` if the asset doesn't exist or has no + /// owner. + fn owner(instance: &Self::InstanceId) -> Option; + + /// Returns the attribute value of `instance` corresponding to `key`. + /// + /// By default this is `None`; no attributes are defined. + fn attribute(_instance: &Self::InstanceId, _key: &[u8]) -> Option> { None } + + /// Returns the strongly-typed attribute value of `instance` corresponding to `key`. + /// + /// By default this just attempts to use `attribute`. + fn typed_attribute(instance: &Self::InstanceId, key: &K) -> Option { + key.using_encoded(|d| Self::attribute(instance, d)) + .and_then(|v| V::decode(&mut &v[..]).ok()) + } + + /// Returns `true` if the asset `instance` may be transferred. + /// + /// Default implementation is that all assets are transferable. + fn can_transfer(_instance: &Self::InstanceId) -> bool { true } +} + +/// Interface for enumerating assets in existence or owned by a given account over a collection +/// of NFTs. +/// +/// WARNING: These may be a heavy operations. Do not use when execution time is limited. +pub trait InspectEnumerable: Inspect { + /// Returns the instances of an asset `class` in existence. + fn instances() -> Vec; + + /// Returns the asset instances of all classes owned by `who`. + fn owned(who: &AccountId) -> Vec; +} + +/// Trait for providing an interface for NFT-like assets which may be minted, burned and/or have +/// attributes set on them. +pub trait Mutate: Inspect { + /// Mint some asset `instance` to be owned by `who`. + /// + /// By default, this is not a supported operation. + fn mint_into(_instance: &Self::InstanceId, _who: &AccountId) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Burn some asset `instance`. + /// + /// By default, this is not a supported operation. + fn burn_from(_instance: &Self::InstanceId) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Set attribute `value` of asset `instance`'s `key`. + /// + /// By default, this is not a supported operation. + fn set_attribute(_instance: &Self::InstanceId, _key: &[u8], _value: &[u8]) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Attempt to set the strongly-typed attribute `value` of `instance`'s `key`. + /// + /// By default this just attempts to use `set_attribute`. + fn set_typed_attribute( + instance: &Self::InstanceId, + key: &K, + value: &V, + ) -> DispatchResult { + key.using_encoded(|k| value.using_encoded(|v| Self::set_attribute(instance, k, v))) + } +} + +/// Trait for providing a non-fungible set of assets which can only be transferred. +pub trait Transfer: Inspect { + /// Transfer asset `instance` into `destination` account. + fn transfer(instance: &Self::InstanceId, destination: &AccountId) -> DispatchResult; +} + +/// Convert a `fungibles` trait implementation into a `fungible` trait implementation by identifying +/// a single item. +pub struct ItemOf< + F: nonfungibles::Inspect, + A: Get<>::ClassId>, + AccountId, +>( + sp_std::marker::PhantomData<(F, A, AccountId)> +); + +impl< + F: nonfungibles::Inspect, + A: Get<>::ClassId>, + AccountId, +> Inspect for ItemOf { + type InstanceId = >::InstanceId; + fn owner(instance: &Self::InstanceId) -> Option { + >::owner(&A::get(), instance) + } + fn attribute(instance: &Self::InstanceId, key: &[u8]) -> Option> { + >::attribute(&A::get(), instance, key) + } + fn typed_attribute(instance: &Self::InstanceId, key: &K) -> Option { + >::typed_attribute(&A::get(), instance, key) + } + fn can_transfer(instance: &Self::InstanceId) -> bool { + >::can_transfer(&A::get(), instance) + } +} + +impl< + F: nonfungibles::InspectEnumerable, + A: Get<>::ClassId>, + AccountId, +> InspectEnumerable for ItemOf { + fn instances() -> Vec { + >::instances(&A::get()) + } + fn owned(who: &AccountId) -> Vec { + >::owned_in_class(&A::get(), who) + } +} + +impl< + F: nonfungibles::Mutate, + A: Get<>::ClassId>, + AccountId, +> Mutate for ItemOf { + fn mint_into(instance: &Self::InstanceId, who: &AccountId) -> DispatchResult { + >::mint_into(&A::get(), instance, who) + } + fn burn_from(instance: &Self::InstanceId) -> DispatchResult { + >::burn_from(&A::get(), instance) + } + fn set_attribute(instance: &Self::InstanceId, key: &[u8], value: &[u8]) -> DispatchResult { + >::set_attribute(&A::get(), instance, key, value) + } + fn set_typed_attribute( + instance: &Self::InstanceId, + key: &K, + value: &V, + ) -> DispatchResult { + >::set_typed_attribute(&A::get(), instance, key, value) + } +} + +impl< + F: nonfungibles::Transfer, + A: Get<>::ClassId>, + AccountId, +> Transfer for ItemOf { + fn transfer(instance: &Self::InstanceId, destination: &AccountId) -> DispatchResult { + >::transfer(&A::get(), instance, destination) + } +} diff --git a/frame/support/src/traits/tokens/nonfungibles.rs b/frame/support/src/traits/tokens/nonfungibles.rs new file mode 100644 index 0000000000000..56db553d83ac1 --- /dev/null +++ b/frame/support/src/traits/tokens/nonfungibles.rs @@ -0,0 +1,194 @@ +// This file is part of Substrate. + +// Copyright (C) 2019-2021 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Traits for dealing with multiple collections of non-fungible assets. +//! +//! This assumes a dual-level namespace identified by `Inspect::InstanceId`, and could +//! reasonably be implemented by pallets which want to expose multiple independent collections of +//! NFT-like objects. +//! +//! For an NFT API which has single-level namespacing, the traits in `nonfungible` are better to +//! use. +//! +//! Implementations of these traits may be converted to implementations of corresponding +//! `nonfungible` traits by using the `nonfungible::ItemOf` type adapter. + +use sp_std::prelude::*; +use codec::{Encode, Decode}; +use sp_runtime::TokenError; +use crate::dispatch::DispatchResult; + +/// Trait for providing an interface to many read-only NFT-like sets of asset instances. +pub trait Inspect { + /// Type for identifying an asset instance. + type InstanceId; + + /// Type for identifying an asset class (an identifier for an independent collection of asset + /// instances). + type ClassId; + + /// Returns the owner of asset `instance` of `class`, or `None` if the asset doesn't exist (or + /// somehow has no owner). + fn owner(class: &Self::ClassId, instance: &Self::InstanceId) -> Option; + + /// Returns the owner of the asset `class`, if there is one. For many NFTs this may not make + /// any sense, so users of this API should not be surprised to find an asset class results in + /// `None` here. + fn class_owner(_class: &Self::ClassId) -> Option { None } + + /// Returns the attribute value of `instance` of `class` corresponding to `key`. + /// + /// By default this is `None`; no attributes are defined. + fn attribute(_class: &Self::ClassId, _instance: &Self::InstanceId, _key: &[u8]) + -> Option> + { + None + } + + /// Returns the strongly-typed attribute value of `instance` of `class` corresponding to `key`. + /// + /// By default this just attempts to use `attribute`. + fn typed_attribute( + class: &Self::ClassId, + instance: &Self::InstanceId, + key: &K, + ) -> Option { + key.using_encoded(|d| Self::attribute(class, instance, d)) + .and_then(|v| V::decode(&mut &v[..]).ok()) + } + + /// Returns the attribute value of `class` corresponding to `key`. + /// + /// By default this is `None`; no attributes are defined. + fn class_attribute(_class: &Self::ClassId, _key: &[u8]) -> Option> { None } + + /// Returns the strongly-typed attribute value of `class` corresponding to `key`. + /// + /// By default this just attempts to use `class_attribute`. + fn typed_class_attribute( + class: &Self::ClassId, + key: &K, + ) -> Option { + key.using_encoded(|d| Self::class_attribute(class, d)) + .and_then(|v| V::decode(&mut &v[..]).ok()) + } + + /// Returns `true` if the asset `instance` of `class` may be transferred. + /// + /// Default implementation is that all assets are transferable. + fn can_transfer(_class: &Self::ClassId, _instance: &Self::InstanceId) -> bool { true } +} + +/// Interface for enumerating assets in existence or owned by a given account over many collections +/// of NFTs. +/// +/// WARNING: These may be a heavy operations. Do not use when execution time is limited. +pub trait InspectEnumerable: Inspect { + /// Returns the asset classes in existence. + fn classes() -> Vec; + + /// Returns the instances of an asset `class` in existence. + fn instances(class: &Self::ClassId) -> Vec; + + /// Returns the asset instances of all classes owned by `who`. + fn owned(who: &AccountId) -> Vec<(Self::ClassId, Self::InstanceId)>; + + /// Returns the asset instances of `class` owned by `who`. + fn owned_in_class(class: &Self::ClassId, who: &AccountId) -> Vec; +} + +/// Trait for providing an interface for multiple classes of NFT-like assets which may be minted, +/// burned and/or have attributes set on them. +pub trait Mutate: Inspect { + /// Mint some asset `instance` of `class` to be owned by `who`. + /// + /// By default, this is not a supported operation. + fn mint_into( + _class: &Self::ClassId, + _instance: &Self::InstanceId, + _who: &AccountId, + ) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Burn some asset `instance` of `class`. + /// + /// By default, this is not a supported operation. + fn burn_from(_class: &Self::ClassId, _instance: &Self::InstanceId) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Set attribute `value` of asset `instance` of `class`'s `key`. + /// + /// By default, this is not a supported operation. + fn set_attribute( + _class: &Self::ClassId, + _instance: &Self::InstanceId, + _key: &[u8], + _value: &[u8], + ) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Attempt to set the strongly-typed attribute `value` of `instance` of `class`'s `key`. + /// + /// By default this just attempts to use `set_attribute`. + fn set_typed_attribute( + class: &Self::ClassId, + instance: &Self::InstanceId, + key: &K, + value: &V, + ) -> DispatchResult { + key.using_encoded(|k| value.using_encoded(|v| + Self::set_attribute(class, instance, k, v) + )) + } + + /// Set attribute `value` of asset `class`'s `key`. + /// + /// By default, this is not a supported operation. + fn set_class_attribute( + _class: &Self::ClassId, + _key: &[u8], + _value: &[u8], + ) -> DispatchResult { + Err(TokenError::Unsupported.into()) + } + + /// Attempt to set the strongly-typed attribute `value` of `class`'s `key`. + /// + /// By default this just attempts to use `set_attribute`. + fn set_typed_class_attribute( + class: &Self::ClassId, + key: &K, + value: &V, + ) -> DispatchResult { + key.using_encoded(|k| value.using_encoded(|v| + Self::set_class_attribute(class, k, v) + )) + } +} + +/// Trait for providing a non-fungible sets of assets which can only be transferred. +pub trait Transfer: Inspect { + /// Transfer asset `instance` of `class` into `destination` account. + fn transfer( + class: &Self::ClassId, + instance: &Self::InstanceId, + destination: &AccountId, + ) -> DispatchResult; +} diff --git a/frame/uniques/src/functions.rs b/frame/uniques/src/functions.rs new file mode 100644 index 0000000000000..28ff5ac6a7033 --- /dev/null +++ b/frame/uniques/src/functions.rs @@ -0,0 +1,115 @@ +// This file is part of Substrate. + +// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Various pieces of common functionality. + +use super::*; +use frame_support::{ensure, traits::Get}; +use sp_runtime::{DispatchResult, DispatchError}; + +impl, I: 'static> Pallet { + pub(crate) fn do_transfer( + class: T::ClassId, + instance: T::InstanceId, + dest: T::AccountId, + with_details: impl FnOnce( + &ClassDetailsFor, + &mut InstanceDetailsFor, + ) -> DispatchResult, + ) -> DispatchResult { + let class_details = Class::::get(&class).ok_or(Error::::Unknown)?; + ensure!(!class_details.is_frozen, Error::::Frozen); + + let mut details = Asset::::get(&class, &instance).ok_or(Error::::Unknown)?; + ensure!(!details.is_frozen, Error::::Frozen); + with_details(&class_details, &mut details)?; + + Account::::remove((&details.owner, &class, &instance)); + Account::::insert((&dest, &class, &instance), ()); + let origin = details.owner; + details.owner = dest; + Asset::::insert(&class, &instance, &details); + + Self::deposit_event(Event::Transferred(class, instance, origin, details.owner)); + Ok(()) + } + + pub(super) fn do_mint( + class: T::ClassId, + instance: T::InstanceId, + owner: T::AccountId, + with_details: impl FnOnce( + &ClassDetailsFor, + ) -> DispatchResult, + ) -> DispatchResult { + ensure!(!Asset::::contains_key(class, instance), Error::::AlreadyExists); + + Class::::try_mutate(&class, |maybe_class_details| -> DispatchResult { + let class_details = maybe_class_details.as_mut().ok_or(Error::::Unknown)?; + + with_details(&class_details)?; + + let instances = class_details.instances.checked_add(1) + .ok_or(ArithmeticError::Overflow)?; + class_details.instances = instances; + + let deposit = match class_details.free_holding { + true => Zero::zero(), + false => T::InstanceDeposit::get(), + }; + T::Currency::reserve(&class_details.owner, deposit)?; + class_details.total_deposit += deposit; + + let owner = owner.clone(); + Account::::insert((&owner, &class, &instance), ()); + let details = InstanceDetails { owner, approved: None, is_frozen: false, deposit}; + Asset::::insert(&class, &instance, details); + Ok(()) + })?; + + Self::deposit_event(Event::Issued(class, instance, owner)); + Ok(()) + } + + pub(super) fn do_burn( + class: T::ClassId, + instance: T::InstanceId, + with_details: impl FnOnce( + &ClassDetailsFor, + &InstanceDetailsFor, + ) -> DispatchResult, + ) -> DispatchResult { + let owner = Class::::try_mutate(&class, |maybe_class_details| -> Result { + let class_details = maybe_class_details.as_mut().ok_or(Error::::Unknown)?; + let details = Asset::::get(&class, &instance) + .ok_or(Error::::Unknown)?; + with_details(&class_details, &details)?; + + // Return the deposit. + T::Currency::unreserve(&class_details.owner, details.deposit); + class_details.total_deposit.saturating_reduce(details.deposit); + class_details.instances.saturating_dec(); + Ok(details.owner) + })?; + + Asset::::remove(&class, &instance); + Account::::remove((&owner, &class, &instance)); + + Self::deposit_event(Event::Burned(class, instance, owner)); + Ok(()) + } +} diff --git a/frame/uniques/src/impl_nonfungibles.rs b/frame/uniques/src/impl_nonfungibles.rs new file mode 100644 index 0000000000000..c856e2cc5588b --- /dev/null +++ b/frame/uniques/src/impl_nonfungibles.rs @@ -0,0 +1,108 @@ +// This file is part of Substrate. + +// Copyright (C) 2017-2021 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Implementations for `nonfungibles` traits. + +use super::*; +use sp_std::convert::TryFrom; +use frame_support::traits::tokens::nonfungibles::{Inspect, Mutate, Transfer}; +use frame_support::BoundedSlice; +use sp_runtime::DispatchResult; + +impl, I: 'static> Inspect<::AccountId> for Pallet { + type InstanceId = T::InstanceId; + type ClassId = T::ClassId; + + fn owner( + class: &Self::ClassId, + instance: &Self::InstanceId, + ) -> Option<::AccountId> { + Asset::::get(class, instance).map(|a| a.owner) + } + + fn class_owner(class: &Self::ClassId) -> Option<::AccountId> { + Class::::get(class).map(|a| a.owner) + } + + /// Returns the attribute value of `instance` of `class` corresponding to `key`. + /// + /// When `key` is empty, we return the instance metadata value. + /// + /// By default this is `None`; no attributes are defined. + fn attribute(class: &Self::ClassId, instance: &Self::InstanceId, key: &[u8]) + -> Option> + { + if key.is_empty() { + // We make the empty key map to the instance metadata value. + InstanceMetadataOf::::get(class, instance).map(|m| m.data.into()) + } else { + let key = BoundedSlice::<_, _>::try_from(key).ok()?; + Attribute::::get((class, Some(instance), key)).map(|a| a.0.into()) + } + } + + /// Returns the attribute value of `instance` of `class` corresponding to `key`. + /// + /// When `key` is empty, we return the instance metadata value. + /// + /// By default this is `None`; no attributes are defined. + fn class_attribute(class: &Self::ClassId, key: &[u8]) + -> Option> + { + if key.is_empty() { + // We make the empty key map to the instance metadata value. + ClassMetadataOf::::get(class).map(|m| m.data.into()) + } else { + let key = BoundedSlice::<_, _>::try_from(key).ok()?; + Attribute::::get((class, Option::::None, key)).map(|a| a.0.into()) + } + } + + /// Returns `true` if the asset `instance` of `class` may be transferred. + /// + /// Default implementation is that all assets are transferable. + fn can_transfer(class: &Self::ClassId, instance: &Self::InstanceId) -> bool { + match (Class::::get(class), Asset::::get(class, instance)) { + (Some(cd), Some(id)) if !cd.is_frozen && !id.is_frozen => true, + _ => false, + } + } +} + +impl, I: 'static> Mutate<::AccountId> for Pallet { + fn mint_into( + class: &Self::ClassId, + instance: &Self::InstanceId, + who: &T::AccountId, + ) -> DispatchResult { + Self::do_mint(class.clone(), instance.clone(), who.clone(), |_| Ok(())) + } + + fn burn_from(class: &Self::ClassId, instance: &Self::InstanceId) -> DispatchResult { + Self::do_burn(class.clone(), instance.clone(), |_, _| Ok(())) + } +} + +impl, I: 'static> Transfer for Pallet { + fn transfer( + class: &Self::ClassId, + instance: &Self::InstanceId, + destination: &T::AccountId, + ) -> DispatchResult { + Self::do_transfer(class.clone(), instance.clone(), destination.clone(), |_, _| Ok(())) + } +} diff --git a/frame/uniques/src/lib.rs b/frame/uniques/src/lib.rs index 21142a3a92ce0..f4a0228de4a89 100644 --- a/frame/uniques/src/lib.rs +++ b/frame/uniques/src/lib.rs @@ -36,6 +36,8 @@ pub mod mock; mod tests; mod types; +mod functions; +mod impl_nonfungibles; pub use types::*; use sp_std::prelude::*; @@ -448,32 +450,10 @@ pub mod pallet { let origin = ensure_signed(origin)?; let owner = T::Lookup::lookup(owner)?; - ensure!(!Asset::::contains_key(class, instance), Error::::AlreadyExists); - - Class::::try_mutate(&class, |maybe_class_details| -> DispatchResult { - let class_details = maybe_class_details.as_mut().ok_or(Error::::Unknown)?; + Self::do_mint(class, instance, owner, |class_details| { ensure!(class_details.issuer == origin, Error::::NoPermission); - - let instances = class_details.instances.checked_add(1) - .ok_or(ArithmeticError::Overflow)?; - class_details.instances = instances; - - let deposit = match class_details.free_holding { - true => Zero::zero(), - false => T::InstanceDeposit::get(), - }; - T::Currency::reserve(&class_details.owner, deposit)?; - class_details.total_deposit += deposit; - - let owner = owner.clone(); - Account::::insert((&owner, &class, &instance), ()); - let details = InstanceDetails { owner, approved: None, is_frozen: false, deposit}; - Asset::::insert(&class, &instance, details); Ok(()) - })?; - - Self::deposit_event(Event::Issued(class, instance, owner)); - Ok(()) + }) } /// Destroy a single asset instance. @@ -499,27 +479,12 @@ pub mod pallet { let origin = ensure_signed(origin)?; let check_owner = check_owner.map(T::Lookup::lookup).transpose()?; - let owner = Class::::try_mutate(&class, |maybe_class_details| -> Result { - let class_details = maybe_class_details.as_mut().ok_or(Error::::Unknown)?; - let details = Asset::::get(&class, &instance) - .ok_or(Error::::Unknown)?; + Self::do_burn(class, instance, |class_details, details| { let is_permitted = class_details.admin == origin || details.owner == origin; ensure!(is_permitted, Error::::NoPermission); ensure!(check_owner.map_or(true, |o| o == details.owner), Error::::WrongOwner); - - // Return the deposit. - T::Currency::unreserve(&class_details.owner, details.deposit); - class_details.total_deposit.saturating_reduce(details.deposit); - class_details.instances.saturating_dec(); - Ok(details.owner) - })?; - - - Asset::::remove(&class, &instance); - Account::::remove((&owner, &class, &instance)); - - Self::deposit_event(Event::Burned(class, instance, owner)); - Ok(()) + Ok(()) + }) } /// Move an asset from the sender account to another. @@ -547,24 +512,13 @@ pub mod pallet { let origin = ensure_signed(origin)?; let dest = T::Lookup::lookup(dest)?; - let class_details = Class::::get(&class).ok_or(Error::::Unknown)?; - ensure!(!class_details.is_frozen, Error::::Frozen); - - let mut details = Asset::::get(&class, &instance).ok_or(Error::::Unknown)?; - ensure!(!details.is_frozen, Error::::Frozen); - if details.owner != origin && class_details.admin != origin { - let approved = details.approved.take().map_or(false, |i| i == origin); - ensure!(approved, Error::::NoPermission); - } - - Account::::remove((&details.owner, &class, &instance)); - Account::::insert((&dest, &class, &instance), ()); - details.owner = dest; - Asset::::insert(&class, &instance, &details); - - Self::deposit_event(Event::Transferred(class, instance, origin, details.owner)); - - Ok(()) + Self::do_transfer(class, instance, dest, |class_details, details| { + if details.owner != origin && class_details.admin != origin { + let approved = details.approved.take().map_or(false, |i| i == origin); + ensure!(approved, Error::::NoPermission); + } + Ok(()) + }) } /// Reevaluate the deposits on some assets. diff --git a/frame/uniques/src/types.rs b/frame/uniques/src/types.rs index 45b571aa7de2c..f73a18c7f3f3d 100644 --- a/frame/uniques/src/types.rs +++ b/frame/uniques/src/types.rs @@ -22,6 +22,11 @@ use frame_support::{traits::Get, BoundedVec}; pub(super) type DepositBalanceOf = <>::Currency as Currency<::AccountId>>::Balance; +pub(super) type ClassDetailsFor = + ClassDetails<::AccountId, DepositBalanceOf>; +pub(super) type InstanceDetailsFor = + InstanceDetails<::AccountId, DepositBalanceOf>; + #[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug)] pub struct ClassDetails< diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs index 0ae69e93980a5..8f7bbf1680c05 100644 --- a/primitives/runtime/src/lib.rs +++ b/primitives/runtime/src/lib.rs @@ -544,6 +544,8 @@ pub enum TokenError { UnknownAsset, /// Funds exist but are frozen. Frozen, + /// Operation is not supported by the asset. + Unsupported, } impl From for &'static str { @@ -555,6 +557,7 @@ impl From for &'static str { TokenError::CannotCreate => "Account cannot be created", TokenError::UnknownAsset => "The asset in question is unknown", TokenError::Frozen => "Funds exist but are frozen", + TokenError::Unsupported => "Operation is not supported by the asset", } } }