Struct AuthorizedKey 

pub struct AuthorizedKey {
    pub signature_type: u8,
    pub expiry: u64,
    pub enforce_limits: bool,
    pub is_revoked: bool,
}

Key information stored in the precompile

Storage layout (packed into single slot, right-aligned):

• byte 0: signature_type (u8)
• bytes 1-8: expiry (u64, little-endian)
• byte 9: enforce_limits (bool)
• byte 10: is_revoked (bool)

Fields

signature_type: u8

Signature type: 0 = secp256k1, 1 = P256, 2 = WebAuthn

expiry: u64

Block timestamp when key expires

enforce_limits: bool

Whether to enforce spending limits for this key

is_revoked: bool

Whether this key has been revoked. Once revoked, a key cannot be re-authorized with the same key_id. This prevents replay attacks.

Trait Implementations

impl Clone for AuthorizedKey

fn clone(&self) -> AuthorizedKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthorizedKey

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

Formats the value using the given formatter.

impl Default for AuthorizedKey

fn default() -> AuthorizedKey

Returns the “default value” for a type.

impl Handler<AuthorizedKey> for AuthorizedKeyHandler

fn t_read(&self) -> Result<AuthorizedKey>

Reads the struct from transient storage.

fn t_write(&mut self, value: AuthorizedKey) -> Result<()>

Writes the struct to transient storage.

fn t_delete(&mut self) -> Result<()>

Deletes the struct from transient storage.

fn read(&self) -> Result<AuthorizedKey>

Reads the value from storage.

fn write(&mut self, value: AuthorizedKey) -> Result<()>

Writes the value to storage.

fn delete(&mut self) -> Result<()>

Deletes the value from storage (sets to zero).

impl PartialEq for AuthorizedKey

fn eq(&self, other: &AuthorizedKey) -> 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 Storable for AuthorizedKey

fn load<S: StorageOps>( storage: &S, base_slot: U256, ctx: LayoutCtx, ) -> Result<Self>

Load this type from storage at the given slot.

fn store<S: StorageOps>( &self, storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Store this type to storage at the given slot.

fn delete<S: StorageOps>( storage: &mut S, base_slot: U256, ctx: LayoutCtx, ) -> Result<()>

Delete this type from storage (set to zero).

impl StorableType for AuthorizedKey

const LAYOUT: Layout

Describes how this type is laid out in storage.

const IS_DYNAMIC: bool

Whether this type stores it’s data in its base slot or not.

type Handler = AuthorizedKeyHandler

The handler type that provides storage access for this type.

fn handle(slot: U256, _ctx: LayoutCtx, address: Address) -> Self::Handler

Creates a handler for this type at the given storage location.

const SLOTS: usize = _

Number of storage slots this type takes.

const BYTES: usize = _

Number of bytes this type takes.

const IS_PACKABLE: bool = _

Whether this type can be packed with adjacent fields.

impl Eq for AuthorizedKey

impl StructuralPartialEq for AuthorizedKey

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes