Enum pallet_xcm::pallet::Call

pub enum Call<T: Config> {
    send {
        dest: Box<VersionedLocation>,
        message: Box<VersionedXcm<()>>,
    },
    teleport_assets {
        dest: Box<VersionedLocation>,
        beneficiary: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        fee_asset_item: u32,
    },
    reserve_transfer_assets {
        dest: Box<VersionedLocation>,
        beneficiary: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        fee_asset_item: u32,
    },
    execute {
        message: Box<VersionedXcm<<T as Config>::RuntimeCall>>,
        max_weight: Weight,
    },
    force_xcm_version {
        location: Box<Location>,
        version: XcmVersion,
    },
    force_default_xcm_version {
        maybe_xcm_version: Option<XcmVersion>,
    },
    force_subscribe_version_notify {
        location: Box<VersionedLocation>,
    },
    force_unsubscribe_version_notify {
        location: Box<VersionedLocation>,
    },
    limited_reserve_transfer_assets {
        dest: Box<VersionedLocation>,
        beneficiary: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        fee_asset_item: u32,
        weight_limit: WeightLimit,
    },
    limited_teleport_assets {
        dest: Box<VersionedLocation>,
        beneficiary: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        fee_asset_item: u32,
        weight_limit: WeightLimit,
    },
    force_suspension {
        suspended: bool,
    },
    transfer_assets {
        dest: Box<VersionedLocation>,
        beneficiary: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        fee_asset_item: u32,
        weight_limit: WeightLimit,
    },
    claim_assets {
        assets: Box<VersionedAssets>,
        beneficiary: Box<VersionedLocation>,
    },
    transfer_assets_using_type_and_then {
        dest: Box<VersionedLocation>,
        assets: Box<VersionedAssets>,
        assets_transfer_type: Box<TransferType>,
        remote_fees_id: Box<VersionedAssetId>,
        fees_transfer_type: Box<TransferType>,
        custom_xcm_on_dest: Box<VersionedXcm<()>>,
        weight_limit: WeightLimit,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

send

Fields

dest: Box<VersionedLocation>

message: Box<VersionedXcm<()>>

teleport_assets

Teleport some assets from the local chain to some destination chain.

This function is deprecated: Use limited_teleport_assets instead.

Fee payment on the destination side is made from the asset in the assets vector of index fee_asset_item. The weight limit for fees is not provided and thus is unlimited, with all fees taken as needed from the asset.

• origin: Must be capable of withdrawing the assets and executing XCM.
• dest: Destination context for the assets. Will typically be [Parent, Parachain(..)] to send from parachain to parachain, or [Parachain(..)] to send from relay to parachain.
• beneficiary: A beneficiary location for the assets in the context of dest. Will generally be an AccountId32 value.
• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest chain.
• fee_asset_item: The index into assets of the item which should be used to pay fees.

Fields

dest: Box<VersionedLocation>

beneficiary: Box<VersionedLocation>

assets: Box<VersionedAssets>

fee_asset_item: u32

reserve_transfer_assets

Transfer some assets from the local chain to the destination chain through their local, destination or remote reserve.

assets must have same reserve location and may not be teleportable to dest.

• assets have local reserve: transfer assets to sovereign account of destination chain and forward a notification XCM to dest to mint and deposit reserve-based assets to beneficiary.
• assets have destination reserve: burn local assets and forward a notification to dest chain to withdraw the reserve assets from this chain’s sovereign account and deposit them to beneficiary.
• assets have remote reserve: burn local assets, forward XCM to reserve chain to move reserves from this chain’s SA to dest chain’s SA, and forward another XCM to dest to mint and deposit reserve-based assets to beneficiary.

This function is deprecated: Use limited_reserve_transfer_assets instead.

Fee payment on the destination side is made from the asset in the assets vector of index fee_asset_item. The weight limit for fees is not provided and thus is unlimited, with all fees taken as needed from the asset.

• origin: Must be capable of withdrawing the assets and executing XCM.
• dest: Destination context for the assets. Will typically be [Parent, Parachain(..)] to send from parachain to parachain, or [Parachain(..)] to send from relay to parachain.
• beneficiary: A beneficiary location for the assets in the context of dest. Will generally be an AccountId32 value.
• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest (and possibly reserve) chains.
• fee_asset_item: The index into assets of the item which should be used to pay fees.

Fields

dest: Box<VersionedLocation>

beneficiary: Box<VersionedLocation>

assets: Box<VersionedAssets>

fee_asset_item: u32

execute

Execute an XCM message from a local, signed, origin.

An event is deposited indicating whether msg could be executed completely or only partially.

No more than max_weight will be used in its attempted execution. If this is less than the maximum amount of weight that the message could take to be executed, then no execution attempt will be made.

Fields

message: Box<VersionedXcm<<T as Config>::RuntimeCall>>

max_weight: Weight

force_xcm_version

Extoll that a particular destination can be communicated with through a particular version of XCM.

• origin: Must be an origin specified by AdminOrigin.
• location: The destination that is being described.
• xcm_version: The latest version of XCM that location supports.

Fields

location: Box<Location>

version: XcmVersion

force_default_xcm_version

Set a safe XCM version (the version that XCM should be encoded with if the most recent version a destination can accept is unknown).

• origin: Must be an origin specified by AdminOrigin.
• maybe_xcm_version: The default XCM encoding version, or None to disable.

Fields

maybe_xcm_version: Option<XcmVersion>

force_subscribe_version_notify

Ask a location to notify us regarding their XCM version and any changes to it.

• origin: Must be an origin specified by AdminOrigin.
• location: The location to which we should subscribe for XCM version notifications.

Fields

location: Box<VersionedLocation>

force_unsubscribe_version_notify

Require that a particular destination should no longer notify us regarding any XCM version changes.

• origin: Must be an origin specified by AdminOrigin.
• location: The location to which we are currently subscribed for XCM version notifications which we no longer desire.

Fields

location: Box<VersionedLocation>

limited_reserve_transfer_assets

Transfer some assets from the local chain to the destination chain through their local, destination or remote reserve.

assets must have same reserve location and may not be teleportable to dest.

• assets have local reserve: transfer assets to sovereign account of destination chain and forward a notification XCM to dest to mint and deposit reserve-based assets to beneficiary.
• assets have destination reserve: burn local assets and forward a notification to dest chain to withdraw the reserve assets from this chain’s sovereign account and deposit them to beneficiary.
• assets have remote reserve: burn local assets, forward XCM to reserve chain to move reserves from this chain’s SA to dest chain’s SA, and forward another XCM to dest to mint and deposit reserve-based assets to beneficiary.

Fee payment on the destination side is made from the asset in the assets vector of index fee_asset_item, up to enough to pay for weight_limit of weight. If more weight is needed than weight_limit, then the operation will fail and the sent assets may be at risk.

• origin: Must be capable of withdrawing the assets and executing XCM.
• dest: Destination context for the assets. Will typically be [Parent, Parachain(..)] to send from parachain to parachain, or [Parachain(..)] to send from relay to parachain.
• beneficiary: A beneficiary location for the assets in the context of dest. Will generally be an AccountId32 value.
• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest (and possibly reserve) chains.
• fee_asset_item: The index into assets of the item which should be used to pay fees.
• weight_limit: The remote-side weight limit, if any, for the XCM fee purchase.

Fields

dest: Box<VersionedLocation>

beneficiary: Box<VersionedLocation>

assets: Box<VersionedAssets>

fee_asset_item: u32

weight_limit: WeightLimit

limited_teleport_assets

Teleport some assets from the local chain to some destination chain.

Fee payment on the destination side is made from the asset in the assets vector of index fee_asset_item, up to enough to pay for weight_limit of weight. If more weight is needed than weight_limit, then the operation will fail and the sent assets may be at risk.

• origin: Must be capable of withdrawing the assets and executing XCM.
• dest: Destination context for the assets. Will typically be [Parent, Parachain(..)] to send from parachain to parachain, or [Parachain(..)] to send from relay to parachain.
• beneficiary: A beneficiary location for the assets in the context of dest. Will generally be an AccountId32 value.
• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest chain.
• fee_asset_item: The index into assets of the item which should be used to pay fees.
• weight_limit: The remote-side weight limit, if any, for the XCM fee purchase.

Fields

dest: Box<VersionedLocation>

beneficiary: Box<VersionedLocation>

assets: Box<VersionedAssets>

fee_asset_item: u32

weight_limit: WeightLimit

force_suspension

Set or unset the global suspension state of the XCM executor.

• origin: Must be an origin specified by AdminOrigin.
• suspended: true to suspend, false to resume.

Fields

suspended: bool

transfer_assets

Transfer some assets from the local chain to the destination chain through their local, destination or remote reserve, or through teleports.

Fee payment on the destination side is made from the asset in the assets vector of index fee_asset_item (hence referred to as fees), up to enough to pay for weight_limit of weight. If more weight is needed than weight_limit, then the operation will fail and the sent assets may be at risk.

assets (excluding fees) must have same reserve location or otherwise be teleportable to dest, no limitations imposed on fees.

• for local reserve: transfer assets to sovereign account of destination chain and forward a notification XCM to dest to mint and deposit reserve-based assets to beneficiary.

• for destination reserve: burn local assets and forward a notification to dest chain to withdraw the reserve assets from this chain’s sovereign account and deposit them to beneficiary.

• for remote reserve: burn local assets, forward XCM to reserve chain to move reserves from this chain’s SA to dest chain’s SA, and forward another XCM to dest to mint and deposit reserve-based assets to beneficiary.

• for teleports: burn local assets and forward XCM to dest chain to mint/teleport assets and deposit them to beneficiary.

• origin: Must be capable of withdrawing the assets and executing XCM.

• dest: Destination context for the assets. Will typically be X2(Parent, Parachain(..)) to send from parachain to parachain, or X1(Parachain(..)) to send from relay to parachain.

• beneficiary: A beneficiary location for the assets in the context of dest. Will generally be an AccountId32 value.

• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest (and possibly reserve) chains.

• fee_asset_item: The index into assets of the item which should be used to pay fees.

• weight_limit: The remote-side weight limit, if any, for the XCM fee purchase.

Fields

dest: Box<VersionedLocation>

beneficiary: Box<VersionedLocation>

assets: Box<VersionedAssets>

fee_asset_item: u32

weight_limit: WeightLimit

claim_assets

Claims assets trapped on this pallet because of leftover assets during XCM execution.

• origin: Anyone can call this extrinsic.
• assets: The exact assets that were trapped. Use the version to specify what version was the latest when they were trapped.
• beneficiary: The location/account where the claimed assets will be deposited.

Fields

assets: Box<VersionedAssets>

beneficiary: Box<VersionedLocation>

transfer_assets_using_type_and_then

Transfer assets from the local chain to the destination chain using explicit transfer types for assets and fees.

assets must have same reserve location or may be teleportable to dest. Caller must provide the assets_transfer_type to be used for assets:

• TransferType::LocalReserve: transfer assets to sovereign account of destination chain and forward a notification XCM to dest to mint and deposit reserve-based assets to beneficiary.
• TransferType::DestinationReserve: burn local assets and forward a notification to dest chain to withdraw the reserve assets from this chain’s sovereign account and deposit them to beneficiary.
• TransferType::RemoteReserve(reserve): burn local assets, forward XCM to reserve chain to move reserves from this chain’s SA to dest chain’s SA, and forward another XCM to dest to mint and deposit reserve-based assets to beneficiary. Typically the remote reserve is Asset Hub.
• TransferType::Teleport: burn local assets and forward XCM to dest chain to mint/teleport assets and deposit them to beneficiary.

On the destination chain, as well as any intermediary hops, BuyExecution is used to buy execution using transferred assets identified by remote_fees_id. Make sure enough of the specified remote_fees_id asset is included in the given list of assets. remote_fees_id should be enough to pay for weight_limit. If more weight is needed than weight_limit, then the operation will fail and the sent assets may be at risk.

remote_fees_id may use different transfer type than rest of assets and can be specified through fees_transfer_type.

The caller needs to specify what should happen to the transferred assets once they reach the dest chain. This is done through the custom_xcm_on_dest parameter, which contains the instructions to execute on dest as a final step. This is usually as simple as: Xcm(vec![DepositAsset { assets: Wild(AllCounted(assets.len())), beneficiary }]), but could be something more exotic like sending the assets even further.

• origin: Must be capable of withdrawing the assets and executing XCM.
• dest: Destination context for the assets. Will typically be [Parent, Parachain(..)] to send from parachain to parachain, or [Parachain(..)] to send from relay to parachain, or (parents: 2, (GlobalConsensus(..), ..)) to send from parachain across a bridge to another ecosystem destination.
• assets: The assets to be withdrawn. This should include the assets used to pay the fee on the dest (and possibly reserve) chains.
• assets_transfer_type: The XCM TransferType used to transfer the assets.
• remote_fees_id: One of the included assets to be used to pay fees.
• fees_transfer_type: The XCM TransferType used to transfer the fees assets.
• custom_xcm_on_dest: The XCM to be executed on dest chain as the last step of the transfer, which also determines what happens to the assets on the destination chain.
• weight_limit: The remote-side weight limit, if any, for the XCM fee purchase.

Fields

dest: Box<VersionedLocation>

assets: Box<VersionedAssets>

assets_transfer_type: Box<TransferType>

remote_fees_id: Box<VersionedAssetId>

fees_transfer_type: Box<TransferType>

custom_xcm_on_dest: Box<VersionedXcm<()>>

weight_limit: WeightLimit

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_send( dest: Box<VersionedLocation>, message: Box<VersionedXcm<()>>, ) -> Self

Create a call with the variant send.

pub fn new_call_variant_teleport_assets( dest: Box<VersionedLocation>, beneficiary: Box<VersionedLocation>, assets: Box<VersionedAssets>, fee_asset_item: u32, ) -> Self

Create a call with the variant teleport_assets.

pub fn new_call_variant_reserve_transfer_assets( dest: Box<VersionedLocation>, beneficiary: Box<VersionedLocation>, assets: Box<VersionedAssets>, fee_asset_item: u32, ) -> Self

Create a call with the variant reserve_transfer_assets.

pub fn new_call_variant_execute( message: Box<VersionedXcm<<T as Config>::RuntimeCall>>, max_weight: Weight, ) -> Self

Create a call with the variant execute.

pub fn new_call_variant_force_xcm_version( location: Box<Location>, version: XcmVersion, ) -> Self

Create a call with the variant force_xcm_version.

pub fn new_call_variant_force_default_xcm_version( maybe_xcm_version: Option<XcmVersion>, ) -> Self

Create a call with the variant force_default_xcm_version.

pub fn new_call_variant_force_subscribe_version_notify( location: Box<VersionedLocation>, ) -> Self

Create a call with the variant force_subscribe_version_notify.

pub fn new_call_variant_force_unsubscribe_version_notify( location: Box<VersionedLocation>, ) -> Self

Create a call with the variant force_unsubscribe_version_notify.

pub fn new_call_variant_limited_reserve_transfer_assets( dest: Box<VersionedLocation>, beneficiary: Box<VersionedLocation>, assets: Box<VersionedAssets>, fee_asset_item: u32, weight_limit: WeightLimit, ) -> Self

Create a call with the variant limited_reserve_transfer_assets.

pub fn new_call_variant_limited_teleport_assets( dest: Box<VersionedLocation>, beneficiary: Box<VersionedLocation>, assets: Box<VersionedAssets>, fee_asset_item: u32, weight_limit: WeightLimit, ) -> Self

Create a call with the variant limited_teleport_assets.

pub fn new_call_variant_force_suspension(suspended: bool) -> Self

Create a call with the variant force_suspension.

pub fn new_call_variant_transfer_assets( dest: Box<VersionedLocation>, beneficiary: Box<VersionedLocation>, assets: Box<VersionedAssets>, fee_asset_item: u32, weight_limit: WeightLimit, ) -> Self

Create a call with the variant transfer_assets.

pub fn new_call_variant_claim_assets( assets: Box<VersionedAssets>, beneficiary: Box<VersionedLocation>, ) -> Self

Create a call with the variant claim_assets.

pub fn new_call_variant_transfer_assets_using_type_and_then( dest: Box<VersionedLocation>, assets: Box<VersionedAssets>, assets_transfer_type: Box<TransferType>, remote_fees_id: Box<VersionedAssetId>, fees_transfer_type: Box<TransferType>, custom_xcm_on_dest: Box<VersionedXcm<()>>, weight_limit: WeightLimit, ) -> Self

Create a call with the variant transfer_assets_using_type_and_then.

Trait Implementations

impl<T: Config> CheckIfFeeless for Call<T>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

impl<T: Config> Clone for Call<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Config> Debug for Call<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for Call<T>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Encode for Call<T>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

impl<T: Config> GetCallName for Call<T>

fn get_call_name(&self) -> &'static str

Return the function name of the Call.

fn get_call_names() -> &'static [&'static str]

Return all function names in the same order as [GetCallIndex].

impl<T: Config> GetDispatchInfo for Call<T>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config> PartialEq for Call<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, Box<VersionedXcm<<T as Config>::RuntimeCall>>: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> UnfilteredDispatchable for Call<T>

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

impl<T: Config> EncodeLike for Call<T>

impl<T: Config> Eq for Call<T>