Uniques: An economically-secure basic-featured NFT pallet

Cargo.toml

@@ -125,6 +125,7 @@ members = [
 	"frame/transaction-payment/rpc/runtime-api",
 	"frame/treasury",
 	"frame/tips",
+	"frame/uniques",
 	"frame/utility",
 	"frame/vesting",
 	"primitives/allocator",

bin/node/runtime/Cargo.toml

@@ -85,6 +85,7 @@ pallet-treasury = { version = "3.0.0", default-features = false, path = "../../.
 pallet-utility = { version = "3.0.0", default-features = false, path = "../../../frame/utility" }
 pallet-transaction-payment = { version = "3.0.0", default-features = false, path = "../../../frame/transaction-payment" }
 pallet-transaction-payment-rpc-runtime-api = { version = "3.0.0", default-features = false, path = "../../../frame/transaction-payment/rpc/runtime-api/" }
+pallet-uniques = { version = "3.0.0", default-features = false, path = "../../../frame/uniques" }
 pallet-vesting = { version = "3.0.0", default-features = false, path = "../../../frame/vesting" }
 
 [build-dependencies]
@@ -155,6 +156,7 @@ std = [
 	"sp-version/std",
 	"pallet-society/std",
 	"pallet-recovery/std",
+	"pallet-uniques/std",
 	"pallet-vesting/std",
 	"log/std",
 	"frame-try-runtime/std",
@@ -191,6 +193,7 @@ runtime-benchmarks = [
 	"pallet-tips/runtime-benchmarks",
 	"pallet-treasury/runtime-benchmarks",
 	"pallet-utility/runtime-benchmarks",
+	"pallet-uniques/runtime-benchmarks",
 	"pallet-vesting/runtime-benchmarks",
 	"pallet-offences-benchmarking",
 	"pallet-session-benchmarking",
@@ -234,6 +237,7 @@ try-runtime = [
 	"pallet-utility/try-runtime",
 	"pallet-society/try-runtime",
 	"pallet-recovery/try-runtime",
+	"pallet-uniques/try-runtime",
 	"pallet-vesting/try-runtime",
 	"pallet-gilt/try-runtime",
 ]

bin/node/runtime/src/lib.rs

@@ -1089,6 +1089,30 @@ impl pallet_gilt::Config for Runtime {
 	type WeightInfo = pallet_gilt::weights::SubstrateWeight<Runtime>;
 }
 
+parameter_types! {
+	pub const ClassDeposit: Balance = 100 * DOLLARS;
+	pub const InstanceDeposit: Balance = 1 * DOLLARS;
+	pub const KeyLimit: u32 = 32;
+	pub const ValueLimit: u32 = 256;
+}
+
+impl pallet_uniques::Config for Runtime {
+	type Event = Event;
+	type ClassId = u32;
+	type InstanceId = u32;
+	type Currency = Balances;
+	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
+	type ClassDeposit = ClassDeposit;
+	type InstanceDeposit = InstanceDeposit;
+	type MetadataDepositBase = MetadataDepositBase;
+	type AttributeDepositBase = MetadataDepositBase;
+	type DepositPerByte = MetadataDepositPerByte;
+	type StringLimit = StringLimit;
+	type KeyLimit = KeyLimit;
+	type ValueLimit = ValueLimit;
+	type WeightInfo = pallet_uniques::weights::SubstrateWeight<Runtime>;
+}
+
 construct_runtime!(
 	pub enum Runtime where
 		Block = Block,
@@ -1133,6 +1157,7 @@ construct_runtime!(
 		Mmr: pallet_mmr::{Pallet, Storage},
 		Lottery: pallet_lottery::{Pallet, Call, Storage, Event<T>},
 		Gilt: pallet_gilt::{Pallet, Call, Storage, Event<T>, Config},
+		Uniques: pallet_uniques::{Pallet, Call, Storage, Event<T>},
 	}
 );
 
@@ -1507,6 +1532,7 @@ impl_runtime_apis! {
 			add_benchmark!(params, batches, pallet_timestamp, Timestamp);
 			add_benchmark!(params, batches, pallet_tips, Tips);
 			add_benchmark!(params, batches, pallet_treasury, Treasury);
+			add_benchmark!(params, batches, pallet_uniques, Uniques);
 			add_benchmark!(params, batches, pallet_utility, Utility);
 			add_benchmark!(params, batches, pallet_vesting, Vesting);
 

frame/assets/src/impl_fungibles.rs

@@ -127,26 +127,26 @@ impl<T: Config<I>, I: 'static> fungibles::Unbalanced<T::AccountId> for Pallet<T,
 		});
 	}
 	fn decrease_balance(asset: T::AssetId, who: &T::AccountId, amount: Self::Balance)
-						-> Result<Self::Balance, DispatchError>
+		-> Result<Self::Balance, DispatchError>
 	{
 		let f = DebitFlags { keep_alive: false, best_effort: false };
 		Self::decrease_balance(asset, who, amount, f, |_, _| Ok(()))
 	}
 	fn decrease_balance_at_most(asset: T::AssetId, who: &T::AccountId, amount: Self::Balance)
-								-> Self::Balance
+		-> Self::Balance
 	{
 		let f = DebitFlags { keep_alive: false, best_effort: true };
 		Self::decrease_balance(asset, who, amount, f, |_, _| Ok(()))
 			.unwrap_or(Zero::zero())
 	}
 	fn increase_balance(asset: T::AssetId, who: &T::AccountId, amount: Self::Balance)
-						-> Result<Self::Balance, DispatchError>
+		-> Result<Self::Balance, DispatchError>
 	{
 		Self::increase_balance(asset, who, amount, |_| Ok(()))?;
 		Ok(amount)
 	}
 	fn increase_balance_at_most(asset: T::AssetId, who: &T::AccountId, amount: Self::Balance)
-								-> Self::Balance
+		-> Self::Balance
 	{
 		match Self::increase_balance(asset, who, amount, |_| Ok(())) {
 			Ok(()) => amount,

frame/assets/src/lib.rs

@@ -409,8 +409,6 @@ pub mod pallet {
 		/// - `owner`: The owner of this class of assets. The owner has full superuser permissions
 		/// over this asset, but may later change and configure the permissions using `transfer_ownership`
 		/// and `set_team`.
-		/// - `max_zombies`: The total number of accounts which may hold assets in this class yet
-		/// have no existential deposit.
 		/// - `min_balance`: The minimum balance of this new asset that any single account must
 		/// have. If an account's balance is reduced below this, then it collapses to zero.
 		///
@@ -517,7 +515,7 @@ pub mod pallet {
 		/// - `beneficiary`: The account to be credited with the minted assets.
 		/// - `amount`: The amount of the asset to be minted.
 		///
-		/// Emits `Destroyed` event when successful.
+		/// Emits `Issued` event when successful.
 		///
 		/// Weight: `O(1)`
 		/// Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.
@@ -582,8 +580,8 @@ pub mod pallet {
 		/// to zero.
 		///
 		/// Weight: `O(1)`
-		/// Modes: Pre-existence of `target`; Post-existence of sender; Prior & post zombie-status
-		/// of sender; Account pre-existence of `target`.
+		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+		/// `target`.
 		#[pallet::weight(T::WeightInfo::transfer())]
 		pub(super) fn transfer(
 			origin: OriginFor<T>,
@@ -618,8 +616,8 @@ pub mod pallet {
 		/// to zero.
 		///
 		/// Weight: `O(1)`
-		/// Modes: Pre-existence of `target`; Post-existence of sender; Prior & post zombie-status
-		/// of sender; Account pre-existence of `target`.
+		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+		/// `target`.
 		#[pallet::weight(T::WeightInfo::transfer_keep_alive())]
 		pub(super) fn transfer_keep_alive(
 			origin: OriginFor<T>,
@@ -655,8 +653,8 @@ pub mod pallet {
 		/// to zero.
 		///
 		/// Weight: `O(1)`
-		/// Modes: Pre-existence of `dest`; Post-existence of `source`; Prior & post zombie-status
-		/// of `source`; Account pre-existence of `dest`.
+		/// Modes: Pre-existence of `dest`; Post-existence of `source`; Account pre-existence of
+		/// `dest`.
 		#[pallet::weight(T::WeightInfo::force_transfer())]
 		pub(super) fn force_transfer(
 			origin: OriginFor<T>,
@@ -773,7 +771,7 @@ pub mod pallet {
 		///
 		/// Origin must be Signed and the sender should be the Admin of the asset `id`.
 		///
-		/// - `id`: The identifier of the asset to be frozen.
+		/// - `id`: The identifier of the asset to be thawed.
 		///
 		/// Emits `Thawed`.
 		///

frame/support/src/storage/bounded_vec.rs

@@ -94,6 +94,12 @@ impl<T, S> BoundedVec<T, S> {
 	}
 }
 
+impl<T, S: Get<u32>> From<BoundedVec<T, S>> for Vec<T> {
+	fn from(x: BoundedVec<T, S>) -> Vec<T> {
+		x.0
+	}
+}
+
 impl<T, S: Get<u32>> BoundedVec<T, S> {
 	/// Get the bound of the type in `usize`.
 	pub fn bound() -> usize {

frame/support/src/storage/types/nmap.rs

@@ -272,7 +272,7 @@ where
 
 	/// Iter over all value of the storage.
 	///
-	/// NOTE: If a value failed to decode becaues storage is corrupted then it is skipped.
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
 	pub fn iter_values() -> crate::storage::PrefixIterator<Value> {
 		<Self as crate::storage::StoragePrefixedMap<Value>>::iter_values()
 	}

frame/uniques/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "pallet-uniques"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+license = "Apache-2.0"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME NFT asset management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false }
+sp-std = { version = "3.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "3.0.0", default-features = false, path = "../../primitives/core" }
+sp-runtime = { version = "3.0.0", default-features = false, path = "../../primitives/runtime" }
+frame-support = { version = "3.0.0", default-features = false, path = "../support" }
+frame-system = { version = "3.0.0", default-features = false, path = "../system" }
+frame-benchmarking = { version = "3.1.0", default-features = false, path = "../benchmarking", optional = true }
+
+[dev-dependencies]
+sp-std = { version = "3.0.0", path = "../../primitives/std" }
+sp-core = { version = "3.0.0", path = "../../primitives/core" }
+sp-io = { version = "3.0.0", path = "../../primitives/io" }
+pallet-balances = { version = "3.0.0", path = "../balances" }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"sp-std/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"frame-support/std",
+	"frame-system/std",
+	"frame-benchmarking/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"sp-runtime/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+]
+try-runtime = ["frame-support/try-runtime"]

frame/uniques/README.md

@@ -0,0 +1,117 @@
+# Uniques Module
+
+A simple, secure module for dealing with fungible assets.
+
+## Overview
+
+The Assets module provides functionality for asset management of fungible asset classes
+with a fixed supply, including:
+
+* Asset Issuance
+* Asset Transfer
+* Asset Destruction
+
+To use it in your runtime, you need to implement the assets [`assets::Trait`](https://docs.rs/pallet-assets/latest/pallet_assets/trait.Trait.html).
+
+The supported dispatchable functions are documented in the [`assets::Call`](https://docs.rs/pallet-assets/latest/pallet_assets/enum.Call.html) enum.
+
+### Terminology
+
+* **Asset issuance:** The creation of a new asset, whose total supply will belong to the
+  account that issues the asset.
+* **Asset transfer:** The action of transferring assets from one account to another.
+* **Asset destruction:** The process of an account removing its entire holding of an asset.
+* **Fungible asset:** An asset whose units are interchangeable.
+* **Non-fungible asset:** An asset for which each unit has unique characteristics.
+
+### Goals
+
+The assets system in Substrate is designed to make the following possible:
+
+* Issue a unique asset to its creator's account.
+* Move assets between accounts.
+* Remove an account's balance of an asset when requested by that account's owner and update
+  the asset's total supply.
+
+## Interface
+
+### Dispatchable Functions
+
+* `issue` - Issues the total supply of a new fungible asset to the account of the caller of the function.
+* `transfer` - Transfers an `amount` of units of fungible asset `id` from the balance of
+the function caller's account (`origin`) to a `target` account.
+* `destroy` - Destroys the entire holding of a fungible asset `id` associated with the account
+that called the function.
+
+Please refer to the [`Call`](https://docs.rs/pallet-assets/latest/pallet_assets/enum.Call.html) enum and its associated variants for documentation on each function.
+
+### Public Functions
+<!-- Original author of descriptions: @gavofyork -->
+
+* `balance` - Get the asset `id` balance of `who`.
+* `total_supply` - Get the total supply of an asset `id`.
+
+Please refer to the [`Module`](https://docs.rs/pallet-assets/latest/pallet_assets/struct.Module.html) struct for details on publicly available functions.
+
+## Usage
+
+The following example shows how to use the Assets module in your runtime by exposing public functions to:
+
+* Issue a new fungible asset for a token distribution event (airdrop).
+* Query the fungible asset holding balance of an account.
+* Query the total supply of a fungible asset that has been issued.
+
+### Prerequisites
+
+Import the Assets module and types and derive your runtime's configuration traits from the Assets module trait.
+
+### Simple Code Snippet
+
+```rust
+use pallet_assets as assets;
+use frame_support::{decl_module, dispatch, ensure};
+use frame_system::ensure_signed;
+use sp_runtime::ArithmeticError;
+
+pub trait Config: assets::Config { }
+
+decl_module! {
+	pub struct Module<T: Config> for enum Call where origin: T::Origin {
+		pub fn issue_token_airdrop(origin) -> dispatch::DispatchResult {
+			let sender = ensure_signed(origin).map_err(|e| e.as_str())?;
+
+			const ACCOUNT_ALICE: u64 = 1;
+			const ACCOUNT_BOB: u64 = 2;
+			const COUNT_AIRDROP_RECIPIENTS: u64 = 2;
+			const TOKENS_FIXED_SUPPLY: u64 = 100;
+
+			ensure!(!COUNT_AIRDROP_RECIPIENTS.is_zero(), ArithmeticError::DivisionByZero);
+
+			let asset_id = Self::next_asset_id();
+
+			<NextAssetId<T>>::mutate(|asset_id| *asset_id += 1);
+			<Balances<T>>::insert((asset_id, &ACCOUNT_ALICE), TOKENS_FIXED_SUPPLY / COUNT_AIRDROP_RECIPIENTS);
+			<Balances<T>>::insert((asset_id, &ACCOUNT_BOB), TOKENS_FIXED_SUPPLY / COUNT_AIRDROP_RECIPIENTS);
+			<TotalSupply<T>>::insert(asset_id, TOKENS_FIXED_SUPPLY);
+
+			Self::deposit_event(RawEvent::Issued(asset_id, sender, TOKENS_FIXED_SUPPLY));
+			Ok(())
+		}
+	}
+}
+```
+
+## Assumptions
+
+Below are assumptions that must be held when using this module.  If any of
+them are violated, the behavior of this module is undefined.
+
+* The total count of assets should be less than
+  `Config::AssetId::max_value()`.
+
+## Related Modules
+
+* [`System`](https://docs.rs/frame-system/latest/frame_system/)
+* [`Support`](https://docs.rs/frame-support/latest/frame_support/)
+
+License: Apache-2.0