Struct AssetsInHolding 

pub struct AssetsInHolding {
    pub fungible: BTreeMap<AssetId, Box<dyn ImbalanceAccounting<u128>>>,
    pub non_fungible: BTreeSet<(AssetId, AssetInstance)>,
}

Map of non-wildcard fungible and non-fungible assets held in the holding register.

Fields

fungible: BTreeMap<AssetId, Box<dyn ImbalanceAccounting<u128>>>

The fungible assets.

non_fungible: BTreeSet<(AssetId, AssetInstance)>

The non-fungible assets.

Implementations

impl AssetsInHolding

pub fn new() -> Self

New value, containing no assets.

pub fn new_from_fungible_credit( asset: AssetId, credit: Box<dyn ImbalanceAccounting<u128>>, ) -> Self

New holding containing a single fungible imbalance.

pub fn new_from_non_fungible(class: AssetId, instance: AssetInstance) -> Self

New holding containing a single non fungible.

pub fn len(&self) -> usize

Total number of distinct assets.

pub fn is_empty(&self) -> bool

Returns true if self contains no assets.

pub fn fungible_assets_iter(&self) -> impl Iterator<Item = Asset> + '_

A borrowing iterator over the fungible assets.

pub fn non_fungible_assets_iter(&self) -> impl Iterator<Item = Asset> + '_

A borrowing iterator over the non-fungible assets.

pub fn into_assets_iter(self) -> impl Iterator<Item = Asset>

A consuming iterator over all assets.

pub fn assets_iter(&self) -> impl Iterator<Item = Asset> + '_

A borrowing iterator over all assets.

pub fn subsume_assets(&mut self, assets: AssetsInHolding)

Mutate self to contain all given assets, saturating if necessary.

NOTE: AssetsInHolding are always sorted

pub fn swapped(&mut self, with: AssetsInHolding) -> Self

Swaps two mutable AssetsInHolding, without deinitializing either one.

pub fn reanchor_and_burn_local( self, target: &Location, context: &InteriorLocation, failed_bin: &mut Self, ) -> Assets

Consume self and return Assets as assets interpreted from the perspective of a target chain. The local chain’s context is provided.

Any assets which were unable to be reanchored are introduced into failed_bin instead.

WARNING: this will drop/resolve any inner imbalances for the reanchored assets. Meant to be used in crosschain operations where the asset is consumed (imbalance dropped/resolved) locally, and a reanchored version of it is to be minted on a remote location.

pub fn reanchored_assets( &self, target: &Location, context: &InteriorLocation, ) -> Assets

Return all inner assets, but interpreted from the perspective of a target chain. The local chain’s context is provided.

Warning: This method returns Assets which only contains amounts (not imbalances). The returned Assets is suitable for cross-chain messaging but does not preserve the imbalance accounting semantics of the original AssetsInHolding. Do not use the returned value for local balance operations that require imbalance tracking.

pub fn contains_asset(&self, asset: &Asset) -> bool

Returns true if asset is contained within self.

pub fn contains_assets(&self, assets: &Assets) -> bool

Returns true if all assets are contained within self.

pub fn ensure_contains(&self, assets: &Assets) -> Result<(), TakeError>

Returns an error unless all assets are contained in self.

pub fn saturating_take(&mut self, asset: AssetFilter) -> Self

Mutates self to its original value less mask and returns true iff it contains at least mask.

Returns Ok with the non-wildcard equivalence of mask taken and mutates self to its value minus mask if self contains asset, and return Err otherwise.

pub fn try_take(&mut self, mask: AssetFilter) -> Result<Self, TakeError>

Mutates self to its original value less mask and returns true iff it contains at least mask.

Returns Ok with the non-wildcard equivalence of asset taken and mutates self to its value minus asset if self contains asset, and return Err otherwise.

pub fn min(&self, mask: &AssetFilter) -> Assets

Return the assets in self, but (asset-wise) of no greater value than mask.

The number of unique assets which are returned will respect the count parameter in the counted wildcard variants of mask.

Example:

use staging_xcm_executor::AssetsInHolding;
use xcm::latest::prelude::*;
// Note: In real usage, AssetsInHolding is created through TransactAsset operations
// For this example, we use Assets type instead to demonstrate the min() output
let assets_i_have: Assets = vec![ (Here, 100).into(), (Junctions::from([GeneralIndex(0)]), 100).into() ].into();
let assets_they_want: AssetFilter = vec![ (Here, 200).into(), (Junctions::from([GeneralIndex(0)]), 50).into() ].into();

// Normally you would call this on AssetsInHolding, but for documentation purposes:
// let assets_we_can_trade: Assets = assets_i_have.min(&assets_they_want);
// assert_eq!(assets_we_can_trade.inner(), &vec![
// 	(Here, 100).into(), (Junctions::from([GeneralIndex(0)]), 50).into(),
// ]);

pub fn unsafe_clone_for_tests(&self) -> Self

Clone this holding for testing purposes only.

This uses unsafe_clone() on the imbalance accounting trait objects, which may not maintain proper accounting invariants. Only use in tests.

Trait Implementations

impl Debug for AssetsInHolding

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for AssetsInHolding

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.