Enum RawOrigin

pub enum RawOrigin<AccountId> {
    Root,
    Signed(AccountId),
    None,
    Authorized,
}

Origin for the System pallet.

Variants

Root

The system itself ordained this dispatch to happen: this is the highest privilege level.

Signed(AccountId)

It is signed by some public key and we provide the AccountId.

None

It is signed by nobody, can be either:

• included and agreed upon by the validators anyway,
• or unsigned transaction validated by a pallet.

Authorized

It is signed by nobody, the extrinsic is authorized by the runtime.

Authorization logic is defined by pallets. See trait Authorize and attribute macro authorize for more details.

Implementations

impl<AccountId> RawOrigin<AccountId>

pub fn as_signed(&self) -> Option<&AccountId>

Returns Some with a reference to the AccountId if self is Signed, None otherwise.

pub fn is_root(&self) -> bool

Returns true if self is Root, None otherwise.

pub fn is_none(&self) -> bool

Returns true if self is None, None otherwise.

Trait Implementations

impl<AccountId: Clone> Clone for RawOrigin<AccountId>

fn clone(&self) -> RawOrigin<AccountId>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AccountId: Debug> Debug for RawOrigin<AccountId>

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

Formats the value using the given formatter.

impl<AccountId> Decode for RawOrigin<AccountId>

where AccountId: Decode,

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<AccountId> Encode for RawOrigin<AccountId>

where AccountId: Encode,

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<AccountId> From<Option<AccountId>> for RawOrigin<AccountId>

fn from(s: Option<AccountId>) -> RawOrigin<AccountId>

Converts to this type from the input type.

impl<AccountId> MaxEncodedLen for RawOrigin<AccountId>

where AccountId: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<AccountId: PartialEq> PartialEq for RawOrigin<AccountId>

fn eq(&self, other: &RawOrigin<AccountId>) -> 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<AccountId> TypeInfo for RawOrigin<AccountId>

where AccountId: TypeInfo + 'static,

type Identity = RawOrigin<AccountId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<AccountId> DecodeWithMemTracking for RawOrigin<AccountId>

where AccountId: DecodeWithMemTracking,

impl<AccountId> EncodeLike for RawOrigin<AccountId>

where AccountId: Encode,

impl<AccountId: Eq> Eq for RawOrigin<AccountId>

impl<AccountId> StructuralPartialEq for RawOrigin<AccountId>