// This file is part of Substrate.

// Copyright (C) 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.

//! # Assets Pallet

//!

//! A simple, secure module for dealing with sets of assets implementing

//! [`fungible`](frame_support::traits::fungible) traits, via [`fungibles`] traits.

//!

//! The pallet makes heavy use of concepts such as Holds and Freezes from the

//! [`frame_support::traits::fungible`] traits, therefore you should read and understand those docs

//! as a prerequisite to understanding this pallet.

//!

//! See the [`frame_tokens`] reference docs for more information about the place of the

//! Assets pallet in FRAME.

//!

//! ## Overview

//!

//! The Assets module provides functionality for asset management of fungible asset classes

//! with a fixed supply, including:

//!

//! * Asset Issuance (Minting)

//! * Asset Transferal

//! * Asset Freezing

//! * Asset Destruction (Burning)

//! * Delegated Asset Transfers ("Approval API")

//!

//! To use it in your runtime, you need to implement the assets [`Config`].

//!

//! The supported dispatchable functions are documented in the [`Call`] enum.

//!

//! ### Terminology

//!

//! * **Admin**: An account ID uniquely privileged to be able to unfreeze (thaw) an account and its

//!   assets, as well as forcibly transfer a particular class of assets between arbitrary accounts

//!   and reduce the balance of a particular class of assets of arbitrary accounts.

//! * **Asset issuance/minting**: The creation of a new asset, whose total supply will belong to the

//!   account designated as the beneficiary of the asset. This is a privileged operation.

//! * **Asset transfer**: The reduction of the balance of an asset of one account with the

//!   corresponding increase in the balance of another.

//! * **Asset destruction**: The process of reducing the balance of an asset of one account. This is

//!   a privileged operation.

//! * **Fungible asset**: An asset whose units are interchangeable.

//! * **Issuer**: An account ID uniquely privileged to be able to mint a particular class of assets.

//! * **Freezer**: An account ID uniquely privileged to be able to freeze an account from

//!   transferring a particular class of assets.

//! * **Freezing**: Removing the possibility of an unpermissioned transfer of an asset from a

//!   particular account.

//! * **Non-fungible asset**: An asset for which each unit has unique characteristics.

//! * **Owner**: An account ID uniquely privileged to be able to destroy a particular asset class,

//!   or to set the Issuer, Freezer or Admin of that asset class.

//! * **Approval**: The act of allowing an account the permission to transfer some balance of asset

//!   from the approving account into some third-party destination account.

//! * **Sufficiency**: The idea of a minimum-balance of an asset being sufficient to allow the

//!   account's existence on the system without requiring any other existential-deposit.

//!

//! ### Goals

//!

//! The assets system in Substrate is designed to make the following possible:

//!

//! * Issue new assets in a permissioned or permissionless way, if permissionless, then with a

//!   deposit required.

//! * Allow accounts to be delegated the ability to transfer assets without otherwise existing

//!   on-chain (*approvals*).

//! * Move assets between accounts.

//! * Update an asset class's total supply.

//! * Allow administrative activities by specially privileged accounts including freezing account

//!   balances and minting/burning assets.

//!

//! ## Interface

//!

//! ### Permissionless Functions

//!

//! * `create`: Creates a new asset class, taking the required deposit.

//! * `transfer`: Transfer sender's assets to another account.

//! * `transfer_keep_alive`: Transfer sender's assets to another account, keeping the sender alive.

//! * `approve_transfer`: Create or increase an delegated transfer.

//! * `cancel_approval`: Rescind a previous approval.

//! * `transfer_approved`: Transfer third-party's assets to another account.

//! * `touch`: Create an asset account for non-provider assets. Caller must place a deposit.

//! * `refund`: Return the deposit (if any) of the caller's asset account or a consumer reference

//!   (if any) of the caller's account.

//! * `refund_other`: Return the deposit (if any) of a specified asset account.

//!

//! ### Permissioned Functions

//!

//! * `force_create`: Creates a new asset class without taking any deposit.

//! * `force_set_metadata`: Set the metadata of an asset class.

//! * `force_clear_metadata`: Remove the metadata of an asset class.

//! * `force_asset_status`: Alter an asset class's attributes.

//! * `force_cancel_approval`: Rescind a previous approval.

//!

//! ### Privileged Functions

//!

//! * `destroy`: Destroys an entire asset class; called by the asset class's Owner.

//! * `mint`: Increases the asset balance of an account; called by the asset class's Issuer.

//! * `burn`: Decreases the asset balance of an account; called by the asset class's Admin.

//! * `force_transfer`: Transfers between arbitrary accounts; called by the asset class's Admin.

//! * `freeze`: Disallows further `transfer`s from an account; called by the asset class's Freezer.

//! * `thaw`: Allows further `transfer`s to and from an account; called by the asset class's Admin.

//! * `transfer_ownership`: Changes an asset class's Owner; called by the asset class's Owner.

//! * `set_team`: Changes an asset class's Admin, Freezer and Issuer; called by the asset class's

//!   Owner.

//! * `set_metadata`: Set the metadata of an asset class; called by the asset class's Owner.

//! * `clear_metadata`: Remove the metadata of an asset class; called by the asset class's Owner.

//! * `touch_other`: Create an asset account for specified account. Caller must place a deposit;

//!   called by the asset class's Freezer or Admin.

//! * `block`: Disallows further `transfer`s to and from an account; called by the asset class's

//!   Freezer.

//!

//! Please refer to the [`Call`] 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 [`Pallet`] struct for details on publicly available functions.

//!

//! ### Callbacks

//!

//! Using `CallbackHandle` associated type, user can configure custom callback functions which are

//! executed when new asset is created or an existing asset is destroyed.

//!

//! ## Related Modules

//!

//! * [`System`](../frame_system/index.html)

//! * [`Support`](../frame_support/index.html)

//!

//! [`frame_tokens`]: ../polkadot_sdk_docs/reference_docs/frame_tokens/index.html

// This recursion limit is needed because we have too many benchmarks and benchmarking will fail if

// we add more without this limit.

#![recursion_limit = "1024"]

// Ensure we're `no_std` when compiling for Wasm.

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(feature = "runtime-benchmarks")]

pub mod benchmarking;

pub mod migration;

#[cfg(test)]

pub mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

mod extra_mutator;

pub use extra_mutator::*;

mod functions;

mod impl_fungibles;

mod impl_stored_map;

mod types;

pub use types::*;

extern crate alloc;

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, Saturating, StaticLookup, Zero},

	ArithmeticError, DispatchError, TokenError,

};

use alloc::vec::Vec;

use core::marker::PhantomData;

use frame_support::{

	dispatch::DispatchResult,

	ensure,

	pallet_prelude::DispatchResultWithPostInfo,

	storage::KeyPrefixIterator,

	traits::{

		tokens::{fungibles, DepositConsequence, WithdrawConsequence},

		BalanceStatus::Reserved,

		Currency, EnsureOriginWithArg, Incrementable, ReservableCurrency, StoredMap,

	},

};

use frame_system::Config as SystemConfig;

pub use pallet::*;

pub use weights::WeightInfo;

type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;

const LOG_TARGET: &str = "runtime::assets";

/// Trait with callbacks that are executed after successful asset creation or destruction.

pub trait AssetsCallback<AssetId, AccountId> {

	/// Indicates that asset with `id` was successfully created by the `owner`

	fn created(_id: &AssetId, _owner: &AccountId) -> Result<(), ()> {

		Ok(())

	}

	/// Indicates that asset with `id` has just been destroyed

	fn destroyed(_id: &AssetId) -> Result<(), ()> {

		Ok(())

	}

}

#[impl_trait_for_tuples::impl_for_tuples(10)]

impl<AssetId, AccountId> AssetsCallback<AssetId, AccountId> for Tuple {

}

/// Auto-increment the [`NextAssetId`] when an asset is created.

///

/// This has not effect if the [`NextAssetId`] value is not present.

pub struct AutoIncAssetId<T, I = ()>(PhantomData<(T, I)>);

impl<T: Config<I>, I> AssetsCallback<T::AssetId, T::AccountId> for AutoIncAssetId<T, I>

where

	T::AssetId: Incrementable,

{

	fn created(_: &T::AssetId, _: &T::AccountId) -> Result<(), ()> {

		let Some(next_id) = NextAssetId::<T, I>::get() else {

			// Auto increment for the asset id is not enabled.

			return Ok(());

		};

		let next_id = next_id.increment().ok_or(())?;

		NextAssetId::<T, I>::put(next_id);

		Ok(())

	}

}

pub mod pallet {

	use super::*;

	use frame_support::{

		pallet_prelude::*,

		traits::{AccountTouch, ContainsPair},

	};

	use frame_system::pallet_prelude::*;

	/// The in-code storage version.

	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);

	#[pallet::storage_version(STORAGE_VERSION)]

	pub struct Pallet<T, I = ()>(_);

	#[cfg(feature = "runtime-benchmarks")]

	pub trait BenchmarkHelper<AssetIdParameter> {

		fn create_asset_id_parameter(id: u32) -> AssetIdParameter;

	}

	#[cfg(feature = "runtime-benchmarks")]

	impl<AssetIdParameter: From<u32>> BenchmarkHelper<AssetIdParameter> for () {

		fn create_asset_id_parameter(id: u32) -> AssetIdParameter {

			id.into()

		}

	}

	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].

	pub mod config_preludes {

		use super::*;

		use frame_support::{derive_impl, traits::ConstU64};

		pub struct TestDefaultConfig;

		#[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)]

		impl frame_system::DefaultConfig for TestDefaultConfig {}

		#[frame_support::register_default_impl(TestDefaultConfig)]

		impl DefaultConfig for TestDefaultConfig {

			#[inject_runtime_type]

			type RuntimeEvent = ();

			type Balance = u64;

			type RemoveItemsLimit = ConstU32<5>;

			type AssetId = u32;

			type AssetIdParameter = u32;

			type AssetDeposit = ConstU64<1>;

			type AssetAccountDeposit = ConstU64<10>;

			type MetadataDepositBase = ConstU64<1>;

			type MetadataDepositPerByte = ConstU64<1>;

			type ApprovalDeposit = ConstU64<1>;

			type StringLimit = ConstU32<50>;

			type Extra = ();

			type CallbackHandle = ();

			type WeightInfo = ();

			#[cfg(feature = "runtime-benchmarks")]

			type BenchmarkHelper = ();

		}

	}

	#[pallet::config(with_default)]

	/// The module configuration trait.

	pub trait Config<I: 'static = ()>: frame_system::Config {

		/// The overarching event type.

		#[pallet::no_default_bounds]

		type RuntimeEvent: From<Event<Self, I>>

			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The units in which we record balances.

		type Balance: Member

			+ Parameter

			+ AtLeast32BitUnsigned

			+ Default

			+ Copy

			+ MaybeSerializeDeserialize

			+ MaxEncodedLen

			+ TypeInfo;

		/// Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call.

		///

		/// Must be configured to result in a weight that makes each call fit in a block.

		#[pallet::constant]

		type RemoveItemsLimit: Get<u32>;

		/// Identifier for the class of asset.

		type AssetId: Member + Parameter + Clone + MaybeSerializeDeserialize + MaxEncodedLen;

		/// Wrapper around `Self::AssetId` to use in dispatchable call signatures. Allows the use

		/// of compact encoding in instances of the pallet, which will prevent breaking changes

		/// resulting from the removal of `HasCompact` from `Self::AssetId`.

		///

		/// This type includes the `From<Self::AssetId>` bound, since tightly coupled pallets may

		/// want to convert an `AssetId` into a parameter for calling dispatchable functions

		/// directly.

		type AssetIdParameter: Parameter + From<Self::AssetId> + Into<Self::AssetId> + MaxEncodedLen;

		/// The currency mechanism.

		#[pallet::no_default]

		type Currency: ReservableCurrency<Self::AccountId>;

		/// Standard asset class creation is only allowed if the origin attempting it and the

		/// asset class are in this set.

		#[pallet::no_default]

		type CreateOrigin: EnsureOriginWithArg<

			Self::RuntimeOrigin,

			Self::AssetId,

			Success = Self::AccountId,

		>;

		/// The origin which may forcibly create or destroy an asset or otherwise alter privileged

		/// attributes.

		#[pallet::no_default]

		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// The basic amount of funds that must be reserved for an asset.

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type AssetDeposit: Get<DepositBalanceOf<Self, I>>;

		/// The amount of funds that must be reserved for a non-provider asset account to be

		/// maintained.

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type AssetAccountDeposit: Get<DepositBalanceOf<Self, I>>;

		/// The basic amount of funds that must be reserved when adding metadata to your asset.

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type MetadataDepositBase: Get<DepositBalanceOf<Self, I>>;

		/// The additional funds that must be reserved for the number of bytes you store in your

		/// metadata.

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type MetadataDepositPerByte: Get<DepositBalanceOf<Self, I>>;

		/// The amount of funds that must be reserved when creating a new approval.

		#[pallet::constant]

		#[pallet::no_default_bounds]

		type ApprovalDeposit: Get<DepositBalanceOf<Self, I>>;

		/// The maximum length of a name or symbol stored on-chain.

		#[pallet::constant]

		type StringLimit: Get<u32>;

		/// A hook to allow a per-asset, per-account minimum balance to be enforced. This must be

		/// respected in all permissionless operations.

		#[pallet::no_default]

		type Freezer: FrozenBalance<Self::AssetId, Self::AccountId, Self::Balance>;

		/// Additional data to be stored with an account's asset balance.

		type Extra: Member + Parameter + Default + MaxEncodedLen;

		/// Callback methods for asset state change (e.g. asset created or destroyed)

		///

		/// Types implementing the [`AssetsCallback`] can be chained when listed together as a

		/// tuple.

		/// The [`AutoIncAssetId`] callback, in conjunction with the [`NextAssetId`], can be

		/// used to set up auto-incrementing asset IDs for this collection.

		type CallbackHandle: AssetsCallback<Self::AssetId, Self::AccountId>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

		/// Helper trait for benchmarks.

		#[cfg(feature = "runtime-benchmarks")]

		type BenchmarkHelper: BenchmarkHelper<Self::AssetIdParameter>;

	}

	/// Details of an asset.

	pub(super) type Asset<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AssetId,

		AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,

	>;

	/// The holdings of a specific account for a specific asset.

	pub(super) type Account<T: Config<I>, I: 'static = ()> = StorageDoubleMap<

		_,

		Blake2_128Concat,

		T::AssetId,

		Blake2_128Concat,

		T::AccountId,

		AssetAccountOf<T, I>,

	>;

	/// Approved balance transfers. First balance is the amount approved for transfer. Second

	/// is the amount of `T::Currency` reserved for storing this.

	/// First key is the asset ID, second key is the owner and third key is the delegate.

	pub(super) type Approvals<T: Config<I>, I: 'static = ()> = StorageNMap<

		_,

		(

			NMapKey<Blake2_128Concat, T::AssetId>,

			NMapKey<Blake2_128Concat, T::AccountId>, // owner

			NMapKey<Blake2_128Concat, T::AccountId>, // delegate

		),

		Approval<T::Balance, DepositBalanceOf<T, I>>,

	>;

	/// Metadata of an asset.

	pub(super) type Metadata<T: Config<I>, I: 'static = ()> = StorageMap<

		_,

		Blake2_128Concat,

		T::AssetId,

		AssetMetadata<DepositBalanceOf<T, I>, BoundedVec<u8, T::StringLimit>>,

		ValueQuery,

	>;

	/// The asset ID enforced for the next asset creation, if any present. Otherwise, this storage

	/// item has no effect.

	///

	/// This can be useful for setting up constraints for IDs of the new assets. For example, by

	/// providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an

	/// auto-increment model can be applied to all new asset IDs.

	///

	/// The initial next asset ID can be set using the [`GenesisConfig`] or the

	/// [SetNextAssetId](`migration::next_asset_id::SetNextAssetId`) migration.

	pub type NextAssetId<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AssetId, OptionQuery>;

	#[pallet::genesis_config]

	#[derive(frame_support::DefaultNoBound)]

	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {

		/// Genesis assets: id, owner, is_sufficient, min_balance

		pub assets: Vec<(T::AssetId, T::AccountId, bool, T::Balance)>,

		/// Genesis metadata: id, name, symbol, decimals

		pub metadata: Vec<(T::AssetId, Vec<u8>, Vec<u8>, u8)>,

		/// Genesis accounts: id, account_id, balance

		pub accounts: Vec<(T::AssetId, T::AccountId, T::Balance)>,

		/// Genesis [`NextAssetId`].

		///

		/// Refer to the [`NextAssetId`] item for more information.

		///

		/// This does not enforce the asset ID for the [assets](`GenesisConfig::assets`) within the

		/// genesis config. It sets the [`NextAssetId`] after they have been created.

		pub next_asset_id: Option<T::AssetId>,

	}

	#[pallet::genesis_build]

	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {

		fn build(&self) {

			for (id, owner, is_sufficient, min_balance) in &self.assets {

				assert!(!Asset::<T, I>::contains_key(id), "Asset id already in use");

				assert!(!min_balance.is_zero(), "Min balance should not be zero");

				Asset::<T, I>::insert(

					id,

					AssetDetails {

						owner: owner.clone(),

						issuer: owner.clone(),

						admin: owner.clone(),

						freezer: owner.clone(),

						supply: Zero::zero(),

						deposit: Zero::zero(),

						min_balance: *min_balance,

						is_sufficient: *is_sufficient,

						accounts: 0,

						sufficients: 0,

						approvals: 0,

						status: AssetStatus::Live,

					},

				);

			}

			for (id, name, symbol, decimals) in &self.metadata {

				assert!(Asset::<T, I>::contains_key(id), "Asset does not exist");

				let bounded_name: BoundedVec<u8, T::StringLimit> =

					name.clone().try_into().expect("asset name is too long");

				let bounded_symbol: BoundedVec<u8, T::StringLimit> =

					symbol.clone().try_into().expect("asset symbol is too long");

				let metadata = AssetMetadata {

					deposit: Zero::zero(),

					name: bounded_name,

					symbol: bounded_symbol,

					decimals: *decimals,

					is_frozen: false,

				};

				Metadata::<T, I>::insert(id, metadata);

			}

			for (id, account_id, amount) in &self.accounts {

				let result = <Pallet<T, I>>::increase_balance(

					id.clone(),

					account_id,

					*amount,

					|details| -> DispatchResult {

						debug_assert!(

							details.supply.checked_add(&amount).is_some(),

							"checked in prep; qed"

						);

						details.supply = details.supply.saturating_add(*amount);

						Ok(())

					},

				);

				assert!(result.is_ok());

			}

			if let Some(next_asset_id) = &self.next_asset_id {

				NextAssetId::<T, I>::put(next_asset_id);

			}

		}

	}

	#[pallet::event]

	pub enum Event<T: Config<I>, I: 'static = ()> {

		Transferred {

		TeamChanged {

		ApprovalsDestroyed {

		MetadataSet {

		ApprovedTransfer {

		/// the approved `delegate`.

		TransferredApproved {

	}

	pub enum Error<T, I = ()> {

	}

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Issue a new class of fungible assets from a public origin.

		///

		/// This new asset class has no assets initially and its owner is the origin.

		///

		/// The origin must conform to the configured `CreateOrigin` and have sufficient funds free.

		///

		/// Funds of sender are reserved by `AssetDeposit`.

		///

		/// Parameters:

		/// - `id`: The identifier of the new asset. This must not be currently in use to identify

		/// an existing asset. If [`NextAssetId`] is set, then this must be equal to it.

		/// - `admin`: The admin of this class of assets. The admin is the initial address of each

		/// member of the asset class's admin team.

		/// - `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.

		///

		/// Emits `Created` event when successful.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(0)]

		pub fn create(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			admin: AccountIdLookupOf<T>,

			min_balance: T::Balance,

		}

		/// Issue a new class of fungible assets from a privileged origin.

		///

		/// This new asset class has no assets initially.

		///

		/// The origin must conform to `ForceOrigin`.

		///

		/// Unlike `create`, no funds are reserved.

		///

		/// - `id`: The identifier of the new asset. This must not be currently in use to identify

		/// an existing asset. If [`NextAssetId`] is set, then this must be equal to it.

		/// - `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`.

		/// - `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.

		///

		/// Emits `ForceCreated` event when successful.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(1)]

		pub fn force_create(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			owner: AccountIdLookupOf<T>,

			is_sufficient: bool,

			#[pallet::compact] min_balance: T::Balance,

		}

		/// Start the process of destroying a fungible asset class.

		///

		/// `start_destroy` is the first in a series of extrinsics that should be called, to allow

		/// destruction of an asset class.

		///

		/// The origin must conform to `ForceOrigin` or must be `Signed` by the asset's `owner`.

		///

		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing

		///   asset.

		///

		/// The asset class must be frozen before calling `start_destroy`.

		#[pallet::call_index(2)]

			};

		}

		/// Destroy all accounts associated with a given asset.

		///

		/// `destroy_accounts` should only be called after `start_destroy` has been called, and the

		/// asset is in a `Destroying` state.

		///

		/// Due to weight restrictions, this function may need to be called multiple times to fully

		/// destroy all accounts. It will destroy `RemoveItemsLimit` accounts at a time.

		///

		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing

		///   asset.

		///

		/// Each call emits the `Event::DestroyedAccounts` event.

		#[pallet::call_index(3)]

		#[pallet::weight(T::WeightInfo::destroy_accounts(T::RemoveItemsLimit::get()))]

		pub fn destroy_accounts(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

		}

		/// Destroy all approvals associated with a given asset up to the max (T::RemoveItemsLimit).

		///

		/// `destroy_approvals` should only be called after `start_destroy` has been called, and the

		/// asset is in a `Destroying` state.

		///

		/// Due to weight restrictions, this function may need to be called multiple times to fully

		/// destroy all approvals. It will destroy `RemoveItemsLimit` approvals at a time.

		///

		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing

		///   asset.

		///

		/// Each call emits the `Event::DestroyedApprovals` event.

		#[pallet::call_index(4)]

		#[pallet::weight(T::WeightInfo::destroy_approvals(T::RemoveItemsLimit::get()))]

		pub fn destroy_approvals(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

		}

		/// Complete destroying asset and unreserve currency.

		///

		/// `finish_destroy` should only be called after `start_destroy` has been called, and the

		/// asset is in a `Destroying` state. All accounts or approvals should be destroyed before

		/// hand.

		///

		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing

		///   asset.

		///

		/// Each successful call emits the `Event::Destroyed` event.

		#[pallet::call_index(5)]

		}

		/// Mint assets of a particular class.

		///

		/// The origin must be Signed and the sender must be the Issuer of the asset `id`.

		///

		/// - `id`: The identifier of the asset to have some amount minted.

		/// - `beneficiary`: The account to be credited with the minted assets.

		/// - `amount`: The amount of the asset to be minted.

		///

		/// Emits `Issued` event when successful.

		///

		/// Weight: `O(1)`

		/// Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.

		#[pallet::call_index(6)]

		pub fn mint(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			beneficiary: AccountIdLookupOf<T>,

			#[pallet::compact] amount: T::Balance,

		}

		/// Reduce the balance of `who` by as much as possible up to `amount` assets of `id`.

		///

		/// Origin must be Signed and the sender should be the Manager of the asset `id`.

		///

		/// Bails with `NoAccount` if the `who` is already dead.

		///

		/// - `id`: The identifier of the asset to have some amount burned.

		/// - `who`: The account to be debited from.

		/// - `amount`: The maximum amount by which `who`'s balance should be reduced.

		///

		/// Emits `Burned` with the actual amount burned. If this takes the balance to below the

		/// minimum for the asset, then the amount burned is increased to take it to zero.

		///

		/// Weight: `O(1)`

		/// Modes: Post-existence of `who`; Pre & post Zombie-status of `who`.

		#[pallet::call_index(7)]

		pub fn burn(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			who: AccountIdLookupOf<T>,

			#[pallet::compact] amount: T::Balance,

		}

		/// Move some assets from the sender account to another.

		///

		/// Origin must be Signed.

		///

		/// - `id`: The identifier of the asset to have some amount transferred.

		/// - `target`: The account to be credited.

		/// - `amount`: The amount by which the sender's balance of assets should be reduced and

		/// `target`'s balance increased. The amount actually transferred may be slightly greater in

		/// the case that the transfer would otherwise take the sender balance above zero but below

		/// the minimum balance. Must be greater than zero.

		///

		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance

		/// to below the minimum for the asset, then the amount transferred is increased to take it

		/// to zero.

		///

		/// Weight: `O(1)`

		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of

		/// `target`.

		#[pallet::call_index(8)]

		pub fn transfer(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			target: AccountIdLookupOf<T>,

			#[pallet::compact] amount: T::Balance,

		}

		/// Move some assets from the sender account to another, keeping the sender account alive.

		///

		/// Origin must be Signed.

		///

		/// - `id`: The identifier of the asset to have some amount transferred.

		/// - `target`: The account to be credited.

		/// - `amount`: The amount by which the sender's balance of assets should be reduced and

		/// `target`'s balance increased. The amount actually transferred may be slightly greater in

		/// the case that the transfer would otherwise take the sender balance above zero but below

		/// the minimum balance. Must be greater than zero.

		///

		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance

		/// to below the minimum for the asset, then the amount transferred is increased to take it

		/// to zero.

		///

		/// Weight: `O(1)`

		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of

		/// `target`.

		#[pallet::call_index(9)]

		pub fn transfer_keep_alive(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			target: AccountIdLookupOf<T>,

			#[pallet::compact] amount: T::Balance,

		}

		/// Move some assets from one account to another.

		///

		/// Origin must be Signed and the sender should be the Admin of the asset `id`.

		///

		/// - `id`: The identifier of the asset to have some amount transferred.

		/// - `source`: The account to be debited.

		/// - `dest`: The account to be credited.

		/// - `amount`: The amount by which the `source`'s balance of assets should be reduced and

		/// `dest`'s balance increased. The amount actually transferred may be slightly greater in

		/// the case that the transfer would otherwise take the `source` balance above zero but

		/// below the minimum balance. Must be greater than zero.

		///

		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance

		/// to below the minimum for the asset, then the amount transferred is increased to take it

		/// to zero.

		///

		/// Weight: `O(1)`

		/// Modes: Pre-existence of `dest`; Post-existence of `source`; Account pre-existence of

		/// `dest`.

		#[pallet::call_index(10)]

		pub fn force_transfer(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			source: AccountIdLookupOf<T>,

			dest: AccountIdLookupOf<T>,

			#[pallet::compact] amount: T::Balance,

		}

		/// Disallow further unprivileged transfers of an asset `id` from an account `who`. `who`

		/// must already exist as an entry in `Account`s of the asset. If you want to freeze an

		/// account that does not have an entry, use `touch_other` first.

		///

		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.

		///

		/// - `id`: The identifier of the asset to be frozen.

		/// - `who`: The account to be frozen.

		///

		/// Emits `Frozen`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(11)]

		pub fn freeze(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			who: AccountIdLookupOf<T>,

			);

		}

		/// Allow unprivileged transfers to and from an account again.

		///

		/// Origin must be Signed and the sender should be the Admin of the asset `id`.

		///

		/// - `id`: The identifier of the asset to be frozen.

		/// - `who`: The account to be unfrozen.

		///

		/// Emits `Thawed`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(12)]

		pub fn thaw(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			who: AccountIdLookupOf<T>,

			);

		}

		/// Disallow further unprivileged transfers for the asset class.

		///

		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.

		///

		/// - `id`: The identifier of the asset to be frozen.

		///

		/// Emits `Frozen`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(13)]

		}

		/// Allow unprivileged transfers for the asset again.

		///

		/// Origin must be Signed and the sender should be the Admin of the asset `id`.

		///

		/// - `id`: The identifier of the asset to be thawed.

		///

		/// Emits `Thawed`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(14)]

		}

		/// Change the Owner of an asset.

		///

		/// Origin must be Signed and the sender should be the Owner of the asset `id`.

		///

		/// - `id`: The identifier of the asset.

		/// - `owner`: The new Owner of this asset.

		///

		/// Emits `OwnerChanged`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(15)]

		pub fn transfer_ownership(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			owner: AccountIdLookupOf<T>,

		}

		/// Change the Issuer, Admin and Freezer of an asset.

		///

		/// Origin must be Signed and the sender should be the Owner of the asset `id`.

		///

		/// - `id`: The identifier of the asset to be frozen.

		/// - `issuer`: The new Issuer of this asset.

		/// - `admin`: The new Admin of this asset.

		/// - `freezer`: The new Freezer of this asset.

		///

		/// Emits `TeamChanged`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(16)]

		pub fn set_team(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			issuer: AccountIdLookupOf<T>,

			admin: AccountIdLookupOf<T>,

			freezer: AccountIdLookupOf<T>,

		}

		/// Set the metadata for an asset.

		///

		/// Origin must be Signed and the sender should be the Owner of the asset `id`.

		///

		/// Funds of sender are reserved according to the formula:

		/// `MetadataDepositBase + MetadataDepositPerByte * (name.len + symbol.len)` taking into

		/// account any already reserved funds.

		///

		/// - `id`: The identifier of the asset to update.

		/// - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.

		/// - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.

		/// - `decimals`: The number of decimals this asset uses to represent one unit.

		///

		/// Emits `MetadataSet`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(17)]

		#[pallet::weight(T::WeightInfo::set_metadata(name.len() as u32, symbol.len() as u32))]

		pub fn set_metadata(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			name: Vec<u8>,

			symbol: Vec<u8>,

			decimals: u8,

		}

		/// Clear the metadata for an asset.

		///

		/// Origin must be Signed and the sender should be the Owner of the asset `id`.

		///

		/// Any deposit is freed for the asset owner.

		///

		/// - `id`: The identifier of the asset to clear.

		///

		/// Emits `MetadataCleared`.

		///

		/// Weight: `O(1)`

		#[pallet::call_index(18)]

		}

		/// Force the metadata for an asset to some value.

		///

		/// Origin must be ForceOrigin.

		///

		/// Any deposit is left alone.

		///

		/// - `id`: The identifier of the asset to update.

		/// - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.

		/// - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.

		/// - `decimals`: The number of decimals this asset uses to represent one unit.

		///

		/// Emits `MetadataSet`.

		///

		/// Weight: `O(N + S)` where N and S are the length of the name and symbol respectively.

		#[pallet::call_index(19)]

		#[pallet::weight(T::WeightInfo::force_set_metadata(name.len() as u32, symbol.len() as u32))]

		pub fn force_set_metadata(

			origin: OriginFor<T>,

			id: T::AssetIdParameter,

			name: Vec<u8>,

			symbol: Vec<u8>,

			decimals: u8,

			is_frozen: bool,