pallet_assets/

impl_fungibles.rs

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

//! Implementations for fungibles trait.

use alloc::vec::Vec;
use frame_support::{
	defensive,
	traits::tokens::{
		Fortitude,
		Precision::{self, BestEffort},
		Preservation::{self, Expendable},
		Provenance::{self, Minted},
	},
};

use super::*;

impl<T: Config<I>, I: 'static> fungibles::Inspect<<T as SystemConfig>::AccountId> for Pallet<T, I> {
	type AssetId = T::AssetId;
	type Balance = T::Balance;

	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
		Asset::<T, I>::get(asset).map(|x| x.supply).unwrap_or_else(Zero::zero)
	}

	fn minimum_balance(asset: Self::AssetId) -> Self::Balance {
		Asset::<T, I>::get(asset).map(|x| x.min_balance).unwrap_or_else(Zero::zero)
	}

	fn balance(asset: Self::AssetId, who: &<T as SystemConfig>::AccountId) -> Self::Balance {
		Pallet::<T, I>::balance(asset, who)
	}

	fn total_balance(asset: Self::AssetId, who: &<T as SystemConfig>::AccountId) -> Self::Balance {
		Pallet::<T, I>::balance(asset.clone(), who)
			.saturating_add(T::Holder::balance_on_hold(asset, who).unwrap_or_default())
	}

	fn reducible_balance(
		asset: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		preservation: Preservation,
		_: Fortitude,
	) -> Self::Balance {
		Pallet::<T, I>::reducible_balance(asset, who, !matches!(preservation, Expendable))
			.unwrap_or(Zero::zero())
	}

	fn can_deposit(
		asset: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
		provenance: Provenance,
	) -> DepositConsequence {
		Pallet::<T, I>::can_increase(asset, who, amount, provenance == Minted)
	}

	fn can_withdraw(
		asset: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) -> WithdrawConsequence<Self::Balance> {
		Pallet::<T, I>::can_decrease(asset, who, amount, false)
	}

	fn asset_exists(asset: Self::AssetId) -> bool {
		Asset::<T, I>::contains_key(asset)
	}

	fn is_sufficient(asset: Self::AssetId) -> bool {
		Asset::<T, I>::get(asset).map(|x| x.is_sufficient).unwrap_or(false)
	}
}

impl<T: Config<I>, I: 'static> fungibles::Mutate<<T as SystemConfig>::AccountId> for Pallet<T, I> {
	fn done_mint_into(
		asset_id: Self::AssetId,
		beneficiary: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		Self::deposit_event(Event::Issued {
			asset_id: asset_id.clone(),
			owner: beneficiary.clone(),
			amount,
		});
		T::CallbackHandle::issued(&asset_id, beneficiary, amount);
	}

	fn done_burn_from(
		asset_id: Self::AssetId,
		target: &<T as SystemConfig>::AccountId,
		balance: Self::Balance,
	) {
		Self::deposit_event(Event::Burned {
			asset_id: asset_id.clone(),
			owner: target.clone(),
			balance,
		});
		T::CallbackHandle::burned(&asset_id, target, balance);
	}

	fn done_shelve(
		asset_id: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		T::CallbackHandle::burned(&asset_id, who, amount);
	}

	fn done_restore(
		asset_id: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		T::CallbackHandle::issued(&asset_id, who, amount);
	}

	fn done_transfer(
		asset_id: Self::AssetId,
		source: &<T as SystemConfig>::AccountId,
		dest: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		Self::deposit_event(Event::Transferred {
			asset_id: asset_id.clone(),
			from: source.clone(),
			to: dest.clone(),
			amount,
		});
		T::CallbackHandle::transferred(&asset_id, source, dest, amount);
	}
}

/// Simple handler for an imbalance drop which increases the total issuance of the system by the
/// imbalance amount. Used for leftover debt. Emits event.
pub struct IncreaseIssuanceWithEvent<T, I>(PhantomData<(T, I)>);
impl<T: Config<I>, I: 'static>
	fungibles::HandleImbalanceDrop<<T as Config<I>>::AssetId, <T as Config<I>>::Balance>
	for IncreaseIssuanceWithEvent<T, I>
{
	fn handle(asset_id: <T as Config<I>>::AssetId, amount: <T as Config<I>>::Balance) {
		fungibles::IncreaseIssuance::<T::AccountId, Pallet<T, I>>::handle(asset_id.clone(), amount);
		Pallet::<T, I>::deposit_event(Event::BurnedDebt { asset_id, amount });
	}
}

/// Simple handler for an imbalance drop which decreases the total issuance of the system by the
/// imbalance amount. Used for leftover credit. Emits event.
pub struct DecreaseIssuanceWithEvent<T, I>(PhantomData<(T, I)>);
impl<T: Config<I>, I: 'static>
	fungibles::HandleImbalanceDrop<<T as Config<I>>::AssetId, <T as Config<I>>::Balance>
	for DecreaseIssuanceWithEvent<T, I>
{
	fn handle(asset_id: <T as Config<I>>::AssetId, amount: <T as Config<I>>::Balance) {
		fungibles::DecreaseIssuance::<T::AccountId, Pallet<T, I>>::handle(asset_id.clone(), amount);
		Pallet::<T, I>::deposit_event(Event::BurnedCredit { asset_id, amount });
	}
}

impl<T: Config<I>, I: 'static> fungibles::Balanced<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	type OnDropCredit = DecreaseIssuanceWithEvent<T, I>;
	type OnDropDebt = IncreaseIssuanceWithEvent<T, I>;

	fn done_deposit(
		asset_id: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		Self::deposit_event(Event::Deposited {
			asset_id: asset_id.clone(),
			who: who.clone(),
			amount,
		});
		T::CallbackHandle::deposited(&asset_id, who, amount);
	}

	fn done_withdraw(
		asset_id: Self::AssetId,
		who: &<T as SystemConfig>::AccountId,
		amount: Self::Balance,
	) {
		Self::deposit_event(Event::Withdrawn {
			asset_id: asset_id.clone(),
			who: who.clone(),
			amount,
		});
		T::CallbackHandle::withdrawn(&asset_id, who, amount);
	}

	fn done_rescind(asset_id: Self::AssetId, amount: Self::Balance) {
		Self::deposit_event(Event::IssuedDebt { asset_id, amount })
	}

	fn done_issue(asset_id: Self::AssetId, amount: Self::Balance) {
		Self::deposit_event(Event::IssuedCredit { asset_id, amount })
	}
}

impl<T: Config<I>, I: 'static> fungibles::Unbalanced<T::AccountId> for Pallet<T, I> {
	fn handle_raw_dust(_: Self::AssetId, _: Self::Balance) {}
	fn handle_dust(_: fungibles::Dust<T::AccountId, Self>) {
		defensive!("`decrease_balance` and `increase_balance` have non-default impls; nothing else calls this; qed");
	}
	fn write_balance(
		_: Self::AssetId,
		_: &T::AccountId,
		_: Self::Balance,
	) -> Result<Option<Self::Balance>, DispatchError> {
		defensive!("write_balance is not used if other functions are impl'd");
		Err(DispatchError::Unavailable)
	}
	fn set_total_issuance(id: T::AssetId, amount: Self::Balance) {
		Asset::<T, I>::mutate_exists(id, |maybe_asset| {
			if let Some(ref mut asset) = maybe_asset {
				asset.supply = amount
			}
		});
	}
	fn decrease_balance(
		asset: T::AssetId,
		who: &T::AccountId,
		amount: Self::Balance,
		precision: Precision,
		preservation: Preservation,
		_: Fortitude,
	) -> Result<Self::Balance, DispatchError> {
		let f = DebitFlags {
			keep_alive: preservation != Expendable,
			best_effort: precision == BestEffort,
		};
		Self::decrease_balance(asset, who, amount, f, |_, _| Ok(()))
	}
	fn increase_balance(
		asset: T::AssetId,
		who: &T::AccountId,
		amount: Self::Balance,
		_: Precision,
	) -> Result<Self::Balance, DispatchError> {
		Self::increase_balance(asset, who, amount, |_| Ok(()))?;
		Ok(amount)
	}

	// TODO: #13196 implement deactivate/reactivate once we have inactive balance tracking.
}

impl<T: Config<I>, I: 'static> fungibles::Create<T::AccountId> for Pallet<T, I> {
	fn create(
		id: T::AssetId,
		admin: T::AccountId,
		is_sufficient: bool,
		min_balance: Self::Balance,
	) -> DispatchResult {
		// Not gated on `ForceOrigin`, so the id must follow `AssetIdAllocator`.
		Self::do_force_create(id, admin, is_sufficient, min_balance, true)
	}
}

impl<T: Config<I>, I: 'static> fungibles::Destroy<T::AccountId> for Pallet<T, I> {
	fn start_destroy(id: T::AssetId, maybe_check_owner: Option<T::AccountId>) -> DispatchResult {
		Self::do_start_destroy(id, maybe_check_owner)
	}

	fn destroy_accounts(id: T::AssetId, max_items: u32) -> Result<u32, DispatchError> {
		Self::do_destroy_accounts(id, max_items)
	}

	fn destroy_approvals(id: T::AssetId, max_items: u32) -> Result<u32, DispatchError> {
		Self::do_destroy_approvals(id, max_items)
	}

	fn finish_destroy(id: T::AssetId) -> DispatchResult {
		Self::do_finish_destroy(id)
	}
}

impl<T: Config<I>, I: 'static> fungibles::metadata::Inspect<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	fn name(asset: T::AssetId) -> Vec<u8> {
		Metadata::<T, I>::get(asset).name.to_vec()
	}

	fn symbol(asset: T::AssetId) -> Vec<u8> {
		Metadata::<T, I>::get(asset).symbol.to_vec()
	}

	fn decimals(asset: T::AssetId) -> u8 {
		Metadata::<T, I>::get(asset).decimals
	}
}

impl<T: Config<I>, I: 'static> fungibles::metadata::Mutate<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	fn set(
		asset: T::AssetId,
		from: &<T as SystemConfig>::AccountId,
		name: Vec<u8>,
		symbol: Vec<u8>,
		decimals: u8,
	) -> DispatchResult {
		Self::do_set_metadata(asset, from, name, symbol, decimals)
	}
}

impl<T: Config<I>, I: 'static>
	fungibles::metadata::MetadataDeposit<
		<T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
	> for Pallet<T, I>
{
	fn calc_metadata_deposit(
		name: &[u8],
		symbol: &[u8],
	) -> <T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance {
		Self::calc_metadata_deposit(&name, &symbol)
	}
}

impl<T: Config<I>, I: 'static> fungibles::approvals::Inspect<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	// Check the amount approved to be spent by an owner to a delegate
	fn allowance(
		asset: T::AssetId,
		owner: &<T as SystemConfig>::AccountId,
		delegate: &<T as SystemConfig>::AccountId,
	) -> T::Balance {
		Approvals::<T, I>::get((asset, &owner, &delegate))
			.map(|x| x.amount)
			.unwrap_or_else(Zero::zero)
	}
}

impl<T: Config<I>, I: 'static> fungibles::approvals::Mutate<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	// Approve spending tokens from a given account
	fn approve(
		asset: T::AssetId,
		owner: &<T as SystemConfig>::AccountId,
		delegate: &<T as SystemConfig>::AccountId,
		amount: T::Balance,
	) -> DispatchResult {
		Self::do_approve_transfer(asset, owner, delegate, amount)
	}

	fn transfer_from(
		asset: T::AssetId,
		owner: &<T as SystemConfig>::AccountId,
		delegate: &<T as SystemConfig>::AccountId,
		dest: &<T as SystemConfig>::AccountId,
		amount: T::Balance,
	) -> DispatchResult {
		Self::do_transfer_approved(asset, owner, delegate, dest, amount)
	}
}

impl<T: Config<I>, I: 'static> fungibles::roles::Inspect<<T as SystemConfig>::AccountId>
	for Pallet<T, I>
{
	fn owner(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
		Asset::<T, I>::get(asset).map(|x| x.owner)
	}

	fn issuer(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
		Asset::<T, I>::get(asset).map(|x| x.issuer)
	}

	fn admin(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
		Asset::<T, I>::get(asset).map(|x| x.admin)
	}

	fn freezer(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
		Asset::<T, I>::get(asset).map(|x| x.freezer)
	}
}

impl<T: Config<I>, I: 'static> fungibles::InspectEnumerable<T::AccountId> for Pallet<T, I> {
	type AssetsIterator = KeyPrefixIterator<<T as Config<I>>::AssetId>;

	/// Returns an iterator of the assets in existence.
	///
	/// NOTE: iterating this list invokes a storage read per item.
	fn asset_ids() -> Self::AssetsIterator {
		Asset::<T, I>::iter_keys()
	}
}

impl<T: Config<I>, I: 'static> fungibles::roles::ResetTeam<T::AccountId> for Pallet<T, I> {
	fn reset_team(
		id: T::AssetId,
		owner: T::AccountId,
		admin: T::AccountId,
		issuer: T::AccountId,
		freezer: T::AccountId,
	) -> DispatchResult {
		Self::do_reset_team(id, owner, admin, issuer, freezer)
	}
}

impl<T: Config<I>, I: 'static> fungibles::Refund<T::AccountId> for Pallet<T, I> {
	type AssetId = T::AssetId;
	type Balance = DepositBalanceOf<T, I>;
	fn deposit_held(id: Self::AssetId, who: T::AccountId) -> Option<(T::AccountId, Self::Balance)> {
		use ExistenceReason::*;
		match Account::<T, I>::get(&id, &who).ok_or(Error::<T, I>::NoDeposit).ok()?.reason {
			DepositHeld(b) => Some((who, b)),
			DepositFrom(d, b) => Some((d, b)),
			_ => None,
		}
	}
	fn refund(id: Self::AssetId, who: T::AccountId) -> DispatchResult {
		match Self::deposit_held(id.clone(), who.clone()) {
			Some((d, _)) if d == who => Self::do_refund(id, who, false),
			Some(..) => Self::do_refund_other(id, &who, None),
			None => Err(Error::<T, I>::NoDeposit.into()),
		}
	}
}