Struct pallet_xcm::pallet::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T>

pub fn send(
    origin: OriginFor<T>,
    dest: Box<VersionedMultiLocation>,
    message: Box<VersionedXcm<()>>
) -> DispatchResult

pub fn teleport_assets(
    origin: OriginFor<T>,
    dest: Box<VersionedMultiLocation>,
    beneficiary: Box<VersionedMultiLocation>,
    assets: Box<VersionedMultiAssets>,
    fee_asset_item: u32
) -> DispatchResult

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. 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 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. The first item should be the currency used to to pay the fee on the dest side. May not be empty.
• fee_asset_item: The index into assets of the item which should be used to pay fees.

pub fn reserve_transfer_assets(
    origin: OriginFor<T>,
    dest: Box<VersionedMultiLocation>,
    beneficiary: Box<VersionedMultiLocation>,
    assets: Box<VersionedMultiAssets>,
    fee_asset_item: u32
) -> DispatchResult

Transfer some assets from the local chain to the sovereign account of a destination chain and forward a notification XCM.

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 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 side.
• fee_asset_item: The index into assets of the item which should be used to pay fees.

pub fn execute(
    origin: OriginFor<T>,
    message: Box<VersionedXcm<<T as SysConfig>::Call>>,
    max_weight: Weight
) -> DispatchResultWithPostInfo

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.

NOTE: A successful return to this does not imply that the msg was executed successfully to completion; only that some of it was executed.

pub fn force_xcm_version(
    origin: OriginFor<T>,
    location: Box<MultiLocation>,
    xcm_version: XcmVersion
) -> DispatchResult

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

• origin: Must be Root.
• location: The destination that is being described.
• xcm_version: The latest version of XCM that location supports.

pub fn force_default_xcm_version(
    origin: OriginFor<T>,
    maybe_xcm_version: Option<XcmVersion>
) -> DispatchResult

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 Root.
• maybe_xcm_version: The default XCM encoding version, or None to disable.

pub fn force_subscribe_version_notify(
    origin: OriginFor<T>,
    location: Box<VersionedMultiLocation>
) -> DispatchResult

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

• origin: Must be Root.
• location: The location to which we should subscribe for XCM version notifications.

pub fn force_unsubscribe_version_notify(
    origin: OriginFor<T>,
    location: Box<VersionedMultiLocation>
) -> DispatchResult

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

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

pub fn limited_reserve_transfer_assets(
    origin: OriginFor<T>,
    dest: Box<VersionedMultiLocation>,
    beneficiary: Box<VersionedMultiLocation>,
    assets: Box<VersionedMultiAssets>,
    fee_asset_item: u32,
    weight_limit: WeightLimit
) -> DispatchResult

Transfer some assets from the local chain to the sovereign account of a destination chain and forward a notification XCM.

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 assets send may be at risk.

• 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 side.
• 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.

pub fn limited_teleport_assets(
    origin: OriginFor<T>,
    dest: Box<VersionedMultiLocation>,
    beneficiary: Box<VersionedMultiLocation>,
    assets: Box<VersionedMultiAssets>,
    fee_asset_item: u32,
    weight_limit: WeightLimit
) -> DispatchResult

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 assets send may be at risk.

• 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. The first item should be the currency used to to pay the fee on the dest side. May not be empty.
• 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.

impl<T: Config> Pallet<T>

pub fn request_version_notify(dest: impl Into<MultiLocation>) -> XcmResult

Request that dest informs us of its version.

pub fn unrequest_version_notify(dest: impl Into<MultiLocation>) -> XcmResult

Request that dest ceases informing us of its version.

pub fn send_xcm(
    interior: impl Into<Junctions>,
    dest: impl Into<MultiLocation>,
    message: Xcm<()>
) -> Result<(), SendError>

Relay an XCM message from a given interior location in this context to a given dest location. A null dest is not handled.

pub fn check_account() -> T::AccountId

pub fn report_outcome(
    message: &mut Xcm<()>,
    responder: impl Into<MultiLocation>,
    timeout: T::BlockNumber
) -> Result<QueryId, XcmError>

Consume message and return another which is equivalent to it except that it reports back the outcome.

• message: The message whose outcome should be reported.
• responder: The origin from which a response should be expected.
• timeout: The block number after which it is permissible for notify not to be called even if a response is received.

report_outcome may return an error if the responder is not invertible.

To check the status of the query, use fn query() passing the resultant QueryId value.

pub fn report_outcome_notify(
    message: &mut Xcm<()>,
    responder: impl Into<MultiLocation>,
    notify: impl Into<<T as Config>::Call>,
    timeout: T::BlockNumber
) -> Result<(), XcmError>

Consume message and return another which is equivalent to it except that it reports back the outcome and dispatches notify on this chain.

• message: The message whose outcome should be reported.
• responder: The origin from which a response should be expected.
• notify: A dispatchable function which will be called once the outcome of message is known. It may be a dispatchable in any pallet of the local chain, but other than the usual origin, it must accept exactly two arguments: query_id: QueryId and outcome: Response, and in that order. It should expect that the origin is Origin::Response and will contain the responder’s location.
• timeout: The block number after which it is permissible for notify not to be called even if a response is received.

report_outcome_notify may return an error if the responder is not invertible.

NOTE: notify gets called as part of handling an incoming message, so it should be lightweight. Its weight is estimated during this function and stored ready for weighing ReportOutcome on the way back. If it turns out to be heavier once it returns then reporting the outcome will fail. Futhermore if the estimate is too high, then it may be put in the overweight queue and need to be manually executed.

pub fn new_query(
    responder: impl Into<MultiLocation>,
    timeout: T::BlockNumber
) -> u64

Attempt to create a new query ID and register it as a query that is yet to respond.

pub fn new_notify_query(
    responder: impl Into<MultiLocation>,
    notify: impl Into<<T as Config>::Call>,
    timeout: T::BlockNumber
) -> u64

Attempt to create a new query ID and register it as a query that is yet to respond, and which will call a dispatchable when a response happens.

pub fn take_response(query_id: QueryId) -> Option<(Response, T::BlockNumber)>

Attempt to remove and return the response of query with ID query_id.

Returns None if the response is not (yet) available.

impl<T: Config> Pallet<T>

pub fn query<KArg>(k: KArg) -> Option<QueryStatus<T::BlockNumber>>where
    KArg: EncodeLike<QueryId>,

The ongoing queries.

impl<T: Config> Pallet<T>

pub fn asset_trap<KArg>(k: KArg) -> u32where
    KArg: EncodeLike<H256>,

The existing asset traps.

Key is the blake2 256 hash of (origin, versioned MultiAssets) pair. Value is the number of times this pair has been trapped (usually just 1 if it exists at all).

Trait Implementations

impl<T: Config> Callable<T> for Pallet<T>

type Call = Call<T>

impl<T: Config> ClaimAssets for Pallet<T>

fn claim_assets(
    origin: &MultiLocation,
    ticket: &MultiLocation,
    assets: &MultiAssets
) -> bool

Claim any assets available to origin and return them in a single Assets value, together with the weight used by this operation.

impl<T> Clone for Pallet<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> Debug for Pallet<T>

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

Formats the value using the given formatter.

impl<T: Config> DropAssets for Pallet<T>

fn drop_assets(origin: &MultiLocation, assets: Assets) -> u64

Handler for receiving dropped assets. Returns the weight consumed by this operation.

impl<T: Config> GetStorageVersion for Pallet<T>

fn current_storage_version() -> StorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

impl<T: Config> Hooks<<T as Config>::BlockNumber> for Pallet<T>

fn on_initialize(_n: BlockNumberFor<T>) -> Weight

The block is being initialized. Implement to have something happen.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn try_state(_n: BlockNumber) -> Result<(), &'static str>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

impl<T: Config> IntegrityTest for Pallet<T>

fn integrity_test()

Run integrity test.

impl<T: Config> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T>

fn offchain_worker(n: <T as Config>::BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Config> OnFinalize<<T as Config>::BlockNumber> for Pallet<T>

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Config> OnGenesis for Pallet<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<T as Config>::BlockNumber> for Pallet<T>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config> OnInitialize<<T as Config>::BlockNumber> for Pallet<T>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

impl<T: Config> OnResponse for Pallet<T>

fn expecting_response(origin: &MultiLocation, query_id: QueryId) -> bool

Returns true if we are expecting a response from origin for query query_id.

fn on_response(
    origin: &MultiLocation,
    query_id: QueryId,
    response: Response,
    max_weight: u64
) -> u64

Handler for receiving a response from origin relating to query_id.

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade.

impl<T: Config> PalletInfoAccess for Pallet<T>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T: Config> PalletsInfoAccess for Pallet<T>

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T> PartialEq<Pallet<T>> for Pallet<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: Config> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config> TryState<<T as Config>::BlockNumber> for Pallet<T>

fn try_state(
    n: <T as Config>::BlockNumber,
    _s: TryStateSelect
) -> Result<(), &'static str>

Execute the state checks.

impl<T: Config> VersionChangeNotifier for Pallet<T>

fn start(dest: &MultiLocation, query_id: QueryId, max_weight: u64) -> XcmResult

Start notifying location should the XCM version of this chain change.

When it does, this type should ensure a QueryResponse message is sent with the given query_id & max_weight and with a response of Repsonse::Version. This should happen until/unless stop is called with the correct query_id.

If the location has an ongoing notification and when this function is called, then an error should be returned.

fn stop(dest: &MultiLocation) -> XcmResult

Stop notifying location should the XCM change. This is a no-op if there was never a subscription.

fn is_subscribed(dest: &MultiLocation) -> bool

Return true if a location is subscribed to XCM version changes.

impl<T: Config> WrapVersion for Pallet<T>

fn wrap_version<Call>(
    dest: &MultiLocation,
    xcm: impl Into<VersionedXcm<Call>>
) -> Result<VersionedXcm<Call>, ()>

impl<T> Eq for Pallet<T>