Enum Call

pub enum Call<T: Config<I>, I: 'static = ()> {
    call {
        xp_id: XpId<T>,
        call: Box<<T as Config<I>>::RuntimeCall>,
    },
    handover {
        xp_id: XpId<T>,
        new_owner: T::AccountId,
    },
    dispose {
        owner: T::AccountId,
        xp_id: XpId<T>,
    },
    force_handover {
        owner: T::AccountId,
        xp_id: XpId<T>,
        new_owner: T::AccountId,
    },
    force_genesis_config {
        field: ForceGenesisConfig<T, I>,
    },
    // some variants omitted
}

XP Pallet Extrinsics includes major state mutation functions with origin authentication. Some read only functions are given for

Variants

call

Executes a runtime call using an XP identity as the origin.

Origin: Signed (must be the owner of the XP identity)

This extrinsic allows the owner of an XP identity to dispatch a call on its behalf. While an XP identity is not a native account, it can act as a logical origin for execution through owner authorization.

The caller must be the registered owner of the given xp_id. Upon successful verification, the provided call is dispatched with the XP identity as the signed origin.

Fields

xp_id: XpId<T>

call: Box<<T as Config<I>>::RuntimeCall>

handover

Transfer or handover ownership of an XP key to another account.

Origin: Signed user (must be the current XP key owner)

This extrinsic allows the current owner of an XP key to transfer ownership to another account. The call will fail if the destination account is already the owner or if the caller does not own the XP key.

On success, ownership of the XP key is transferred to the target account and an event is emitted.

Emits Event::XpOwner with the XP key and new owner.

Fields

xp_id: XpId<T>

new_owner: T::AccountId

dispose

Dispose (Reap) an XP key.

Origin: Signed user

This extrinsic allows any signed account to finalize and remove XP entries that are no longer valid.

For an XP key, it checks:

• The key exists in storage,
• The key is considered “dead” (does not meet minimum timestamp requirements),
• The key has no active locks.

If all checks pass, the XP entry is reaped (removed from storage and blacklisted).

Emits Event::XpReap with each successfully reaped XP key.

Fields

owner: T::AccountId

xp_id: XpId<T>

force_handover

Force transfer/handover ownership of an XP key to another account.

Origin: Root only

This extrinsic allows the current owner of an XP key to transfer ownership to another account. The call will fail if the destination account is already the owner or if the caller does not own the XP key.

On success, ownership of the XP key is transferred to the target account and an event is emitted.

Emits Event::XpOwner with the XP key and new owner.

Fields

owner: T::AccountId

xp_id: XpId<T>

new_owner: T::AccountId

force_genesis_config

Force-update a selected genesis configuration parameter.

Origin: Root only.

This extrinsic allows privileged modification of runtime parameters that were originally defined at genesis.

The parameter to update is specified via the ForceGenesisConfig enum:

• MinPulse - Updates the minimum pulse required for reputation effects.
• InitXp - Updates the initial XP assigned to newly created XP entries.
• PulseFactor - Updates the pulse stepping configuration (threshold and per_count).
• MinTimeStamp - Updated the minimum blocks required for an XP entry to be considered alive.

For PulseFactor, the call fails with Error::LowPulseThreshold if per_count > threshold, as this would invalidate the stepping logic.

This call directly overwrites storage and emits an event containing the updated configuration variant.

Fields

field: ForceGenesisConfig<T, I>

Implementations

impl<T: Config<I>, I: 'static> Call<T, I>

pub fn new_call_variant_call( xp_id: XpId<T>, call: Box<<T as Config<I>>::RuntimeCall>, ) -> Self

Create a call with the variant call.

pub fn new_call_variant_handover( xp_id: XpId<T>, new_owner: T::AccountId, ) -> Self

Create a call with the variant handover.

pub fn new_call_variant_dispose(owner: T::AccountId, xp_id: XpId<T>) -> Self

Create a call with the variant dispose.

pub fn new_call_variant_force_handover( owner: T::AccountId, xp_id: XpId<T>, new_owner: T::AccountId, ) -> Self

Create a call with the variant force_handover.

pub fn new_call_variant_force_genesis_config( field: ForceGenesisConfig<T, I>, ) -> Self

Create a call with the variant force_genesis_config.

Trait Implementations

impl<T: Config<I>, I: 'static> CheckIfFeeless for Call<T, I>

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<I>, I: 'static> Clone for Call<T, I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Config<I>, I: 'static> Debug for Call<T, I>

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

Formats the value using the given formatter.

impl<T: Config<I>, I: 'static> Decode for Call<T, I>

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<I>, I: 'static> Encode for Call<T, I>

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<I>, I: 'static> GetCallIndex for Call<T, I>

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<I>, I: 'static> GetCallName for Call<T, I>

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<I>, I: 'static> GetDispatchInfo for Call<T, I>

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

impl<T: Config<I>, I: 'static> PartialEq for Call<T, I>

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.

impl<T, I> TypeInfo for Call<T, I>

where PhantomData<(T, I)>: TypeInfo + 'static, XpId<T>: TypeInfo + 'static, Box<<T as Config<I>>::RuntimeCall>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, ForceGenesisConfig<T, I>: TypeInfo + 'static, T: Config<I> + 'static, I: 'static,

type Identity = Call<T, I>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config<I>, I: 'static> UnfilteredDispatchable for Call<T, I>

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<I>, I: 'static> DecodeWithMemTracking for Call<T, I>

where XpId<T>: DecodeWithMemTracking, Box<<T as Config<I>>::RuntimeCall>: DecodeWithMemTracking, T::AccountId: DecodeWithMemTracking, ForceGenesisConfig<T, I>: DecodeWithMemTracking,

impl<T: Config<I>, I: 'static> EncodeLike for Call<T, I>

impl<T: Config<I>, I: 'static> Eq for Call<T, I>