Enum pallet_domains::Call

pub enum Call<T: Config> {
    submit_bundle {
        opaque_bundle: OpaqueBundleOf<T>,
    },
    submit_fraud_proof {
        fraud_proof: Box<FraudProofFor<T>>,
    },
    register_domain_runtime {
        runtime_name: String,
        runtime_type: RuntimeType,
        raw_genesis_storage: Vec<u8>,
    },
    upgrade_domain_runtime {
        runtime_id: RuntimeId,
        raw_genesis_storage: Vec<u8>,
    },
    register_operator {
        domain_id: DomainId,
        amount: <T as Config>::Balance,
        config: OperatorConfig<<T as Config>::Balance>,
        signing_key_proof_of_ownership: OperatorSignature,
    },
    nominate_operator {
        operator_id: OperatorId,
        amount: <T as Config>::Balance,
    },
    instantiate_domain {
        domain_config: DomainConfig<T::AccountId, <T as Config>::Balance>,
    },
    deregister_operator {
        operator_id: OperatorId,
    },
    withdraw_stake {
        operator_id: OperatorId,
        to_withdraw: WithdrawStake<<T as Config>::Balance, T::Share>,
    },
    unlock_funds {
        operator_id: OperatorId,
    },
    unlock_nominator {
        operator_id: OperatorId,
    },
    update_domain_operator_allow_list {
        domain_id: DomainId,
        operator_allow_list: OperatorAllowList<T::AccountId>,
    },
    force_staking_epoch_transition {
        domain_id: DomainId,
    },
    set_permissioned_action_allowed_by {
        permissioned_action_allowed_by: PermissionedActionAllowedBy<T::AccountId>,
    },
    send_domain_sudo_call {
        domain_id: DomainId,
        call: Vec<u8>,
    },
    freeze_domain {
        domain_id: DomainId,
    },
    unfreeze_domain {
        domain_id: DomainId,
    },
    prune_domain_execution_receipt {
        domain_id: DomainId,
        bad_receipt_hash: ReceiptHashFor<T>,
    },
    transfer_treasury_funds {
        account_id: T::AccountId,
        balance: <T as Config>::Balance,
    },
    submit_receipt {
        singleton_receipt: SingletonReceiptOf<T>,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

submit_bundle

Fields

opaque_bundle: OpaqueBundleOf<T>

submit_fraud_proof

Fields

fraud_proof: Box<FraudProofFor<T>>

register_domain_runtime

Fields

runtime_name: String

runtime_type: RuntimeType

raw_genesis_storage: Vec<u8>

upgrade_domain_runtime

Fields

runtime_id: RuntimeId

raw_genesis_storage: Vec<u8>

register_operator

Fields

domain_id: DomainId

amount: <T as Config>::Balance

config: OperatorConfig<<T as Config>::Balance>

signing_key_proof_of_ownership: OperatorSignature

nominate_operator

Fields

operator_id: OperatorId

amount: <T as Config>::Balance

instantiate_domain

Fields

domain_config: DomainConfig<T::AccountId, <T as Config>::Balance>

deregister_operator

Fields

operator_id: OperatorId

withdraw_stake

Fields

operator_id: OperatorId

to_withdraw: WithdrawStake<<T as Config>::Balance, T::Share>

unlock_funds

Unlocks the first withdrawal given the unlocking period is complete. Even if rest of the withdrawals are out of unlocking period, nominator should call this extrinsic to unlock each withdrawal

Fields

operator_id: OperatorId

unlock_nominator

Unlocks the nominator under given operator given the unlocking period is complete. A nominator can initiate their unlock given operator is already deregistered.

Fields

operator_id: OperatorId

update_domain_operator_allow_list

Extrinsic to update domain’s operator allow list. Note:

• If the previous allowed list is set to specific operators and new allow list is set to Anyone, then domain will become permissioned to open for all operators.
• If the previous allowed list is set to Anyone or specific operators and the new allow list is set to specific operators, then all the registered not allowed operators will continue to operate until they de-register themselves.

Fields

domain_id: DomainId

operator_allow_list: OperatorAllowList<T::AccountId>

force_staking_epoch_transition

Force staking epoch transition for a given domain

Fields

domain_id: DomainId

set_permissioned_action_allowed_by

Update permissioned action allowed by storage by Sudo.

Fields

permissioned_action_allowed_by: PermissionedActionAllowedBy<T::AccountId>

send_domain_sudo_call

Submit a domain sudo call.

Fields

domain_id: DomainId

call: Vec<u8>

freeze_domain

Freezes a given domain. A frozen domain does not accept new bundles but accepts fraud proofs.

Fields

domain_id: DomainId

unfreeze_domain

Unfreezes a frozen domain.

Fields

domain_id: DomainId

prune_domain_execution_receipt

Prunes a given execution receipt for given frozen domain. This call assumes the execution receipt to be bad and implicitly trusts Sudo to do necessary validation of the ER before dispatching this call.

Fields

domain_id: DomainId

bad_receipt_hash: ReceiptHashFor<T>

transfer_treasury_funds

Transfer funds from treasury to given account

Fields

account_id: T::AccountId

balance: <T as Config>::Balance

submit_receipt

Fields

singleton_receipt: SingletonReceiptOf<T>

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_submit_bundle(opaque_bundle: OpaqueBundleOf<T>) -> Self

Create a call with the variant submit_bundle.

pub fn new_call_variant_submit_fraud_proof( fraud_proof: Box<FraudProofFor<T>>, ) -> Self

Create a call with the variant submit_fraud_proof.

pub fn new_call_variant_register_domain_runtime( runtime_name: String, runtime_type: RuntimeType, raw_genesis_storage: Vec<u8>, ) -> Self

Create a call with the variant register_domain_runtime.

pub fn new_call_variant_upgrade_domain_runtime( runtime_id: RuntimeId, raw_genesis_storage: Vec<u8>, ) -> Self

Create a call with the variant upgrade_domain_runtime.

pub fn new_call_variant_register_operator( domain_id: DomainId, amount: <T as Config>::Balance, config: OperatorConfig<<T as Config>::Balance>, signing_key_proof_of_ownership: OperatorSignature, ) -> Self

Create a call with the variant register_operator.

pub fn new_call_variant_nominate_operator( operator_id: OperatorId, amount: <T as Config>::Balance, ) -> Self

Create a call with the variant nominate_operator.

pub fn new_call_variant_instantiate_domain( domain_config: DomainConfig<T::AccountId, <T as Config>::Balance>, ) -> Self

Create a call with the variant instantiate_domain.

pub fn new_call_variant_deregister_operator(operator_id: OperatorId) -> Self

Create a call with the variant deregister_operator.

pub fn new_call_variant_withdraw_stake( operator_id: OperatorId, to_withdraw: WithdrawStake<<T as Config>::Balance, T::Share>, ) -> Self

Create a call with the variant withdraw_stake.

pub fn new_call_variant_unlock_funds(operator_id: OperatorId) -> Self

Create a call with the variant unlock_funds.

pub fn new_call_variant_unlock_nominator(operator_id: OperatorId) -> Self

Create a call with the variant unlock_nominator.

pub fn new_call_variant_update_domain_operator_allow_list( domain_id: DomainId, operator_allow_list: OperatorAllowList<T::AccountId>, ) -> Self

Create a call with the variant update_domain_operator_allow_list.

pub fn new_call_variant_force_staking_epoch_transition( domain_id: DomainId, ) -> Self

Create a call with the variant force_staking_epoch_transition.

pub fn new_call_variant_set_permissioned_action_allowed_by( permissioned_action_allowed_by: PermissionedActionAllowedBy<T::AccountId>, ) -> Self

Create a call with the variant set_permissioned_action_allowed_by.

pub fn new_call_variant_send_domain_sudo_call( domain_id: DomainId, call: Vec<u8>, ) -> Self

Create a call with the variant send_domain_sudo_call.

pub fn new_call_variant_freeze_domain(domain_id: DomainId) -> Self

Create a call with the variant freeze_domain.

pub fn new_call_variant_unfreeze_domain(domain_id: DomainId) -> Self

Create a call with the variant unfreeze_domain.

pub fn new_call_variant_prune_domain_execution_receipt( domain_id: DomainId, bad_receipt_hash: ReceiptHashFor<T>, ) -> Self

Create a call with the variant prune_domain_execution_receipt.

pub fn new_call_variant_transfer_treasury_funds( account_id: T::AccountId, balance: <T as Config>::Balance, ) -> Self

Create a call with the variant transfer_treasury_funds.

pub fn new_call_variant_submit_receipt( singleton_receipt: SingletonReceiptOf<T>, ) -> Self

Create a call with the variant submit_receipt.

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

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> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, OpaqueBundleOf<T>: TypeInfo + 'static, Box<FraudProofFor<T>>: TypeInfo + 'static, <T as Config>::Balance: TypeInfo + 'static, OperatorConfig<<T as Config>::Balance>: TypeInfo + 'static, DomainConfig<T::AccountId, <T as Config>::Balance>: TypeInfo + 'static, WithdrawStake<<T as Config>::Balance, T::Share>: TypeInfo + 'static, OperatorAllowList<T::AccountId>: TypeInfo + 'static, PermissionedActionAllowedBy<T::AccountId>: TypeInfo + 'static, ReceiptHashFor<T>: TypeInfo + 'static, T::AccountId: TypeInfo + 'static, SingletonReceiptOf<T>: 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>