Struct AffidavitPayload

pub struct AffidavitPayload<Public, AccountId>
where
    Public: Debug + TypeInfo,
    AccountId: Debug + TypeInfo,
{
    pub public: Public,
    pub rotate: AccountId,
}

Unsigned payload for crate::Pallet::declare extrinsic.

• public is the currently active affidavit key, used to authorize the affidavit declaration.
• rotate is the next affidavit key that will be registered and rotated in as the active key for the upcoming session.

The payload is signed offchain using the active affidavit key and verified on-chain via ValidateUnsigned.

Fields

public: Public

Active affidavit public key used for authorization.

rotate: AccountId

Next affidavit key to be rotated in for the upcoming session.

Trait Implementations

impl<Public, AccountId> Clone for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Clone, AccountId: Debug + TypeInfo + Clone,

fn clone(&self) -> AffidavitPayload<Public, AccountId>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Public, AccountId> Debug for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Debug, AccountId: Debug + TypeInfo + Debug,

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

Formats the value using the given formatter.

impl<Public, AccountId> Decode for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Decode, AccountId: Debug + TypeInfo + 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<Public, AccountId> Encode for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Encode, AccountId: Debug + TypeInfo + 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<Public, AccountId> PartialEq for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + PartialEq, AccountId: Debug + TypeInfo + PartialEq,

fn eq(&self, other: &AffidavitPayload<Public, 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<T: SigningTypes<Public = Public>, Public, AccountId> SignedPayload<T> for AffidavitPayload<Public, AccountId>

where Public: Encode + Debug + TypeInfo + Clone, AccountId: Encode + Debug + TypeInfo + Clone,

fn public(&self) -> <T as SigningTypes>::Public

Return a public key that is expected to have a matching key in the keystore, which should be used to sign the payload.

fn sign<C>(&self) -> Option<<T as SigningTypes>::Signature>

where C: AppCrypto<<T as SigningTypes>::Public, <T as SigningTypes>::Signature>,

Sign the payload using the implementor’s provided public key.

fn verify<C>(&self, signature: <T as SigningTypes>::Signature) -> bool

where C: AppCrypto<<T as SigningTypes>::Public, <T as SigningTypes>::Signature>,

Verify signature against payload.

impl<Public, AccountId> TypeInfo for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + TypeInfo + 'static, AccountId: Debug + TypeInfo + TypeInfo + 'static,

type Identity = AffidavitPayload<Public, AccountId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Public, AccountId> DecodeWithMemTracking for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + DecodeWithMemTracking, AccountId: Debug + TypeInfo + DecodeWithMemTracking,

impl<Public, AccountId> EncodeLike for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Encode, AccountId: Debug + TypeInfo + Encode,

impl<Public, AccountId> Eq for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo + Eq, AccountId: Debug + TypeInfo + Eq,

impl<Public, AccountId> StructuralPartialEq for AffidavitPayload<Public, AccountId>

where Public: Debug + TypeInfo, AccountId: Debug + TypeInfo,