Struct AccountKeychain 

pub struct AccountKeychain {
    pub keys: <Mapping<Address, Mapping<Address, AuthorizedKey>> as StorableType>::Handler,
    pub spending_limits: <Mapping<B256, Mapping<Address, U256>> as StorableType>::Handler,
    pub transaction_key: <Address as StorableType>::Handler,
    address: Address,
    storage: StorageCtx,
}

Fields

keys: <Mapping<Address, Mapping<Address, AuthorizedKey>> as StorableType>::Handler

spending_limits: <Mapping<B256, Mapping<Address, U256>> as StorableType>::Handler

transaction_key: <Address as StorableType>::Handler

address: Address

storage: StorageCtx

Implementations

impl AccountKeychain

pub fn new() -> Self

Creates an instance of the precompile.

Caution: This does not initialize the account, see Self::initialize.

fn __new(address: Address) -> Self

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

fn emit_event(&mut self, event: impl IntoLogData) -> Result<()>

fn emitted_events(&self) -> &Vec<LogData>

Available on crate features test-utils only.

fn assert_emitted_events(&self, expected: Vec<impl IntoLogData>)

Available on crate features test-utils only.

impl AccountKeychain

fn spending_limit_key(account: Address, key_id: Address) -> B256

Create a hash key for spending limits mapping from account and keyId

pub fn initialize(&mut self) -> Result<()>

Initializes the account keychain contract.

pub fn authorize_key( &mut self, msg_sender: Address, call: authorizeKeyCall, ) -> Result<()>

Authorize a new key for an account This can only be called by the account itself (using main key)

pub fn revoke_key( &mut self, msg_sender: Address, call: revokeKeyCall, ) -> Result<()>

Revoke an authorized key

This marks the key as revoked by setting is_revoked to true and expiry to 0. Once revoked, a key_id can never be re-authorized for this account, preventing replay attacks where old KeyAuthorization signatures could be reused.

pub fn update_spending_limit( &mut self, msg_sender: Address, call: updateSpendingLimitCall, ) -> Result<()>

Update spending limit for a key-token pair

This can be used to add limits to an unlimited key (converting it to limited) or to update existing limits.

pub fn get_key(&self, call: getKeyCall) -> Result<KeyInfo>

Get key information

pub fn get_remaining_limit(&self, call: getRemainingLimitCall) -> Result<U256>

Get remaining spending limit

pub fn get_transaction_key( &self, _call: getTransactionKeyCall, _msg_sender: Address, ) -> Result<Address>

Get the transaction key used in the current transaction

pub fn set_transaction_key(&mut self, key_id: Address) -> Result<()>

Internal: Set the transaction key (called during transaction validation)

SECURITY CRITICAL: This must be called by the transaction validation logic BEFORE the transaction is executed, to store which key authorized the transaction.

• If key_id is Address::ZERO (main key), this should store Address::ZERO
• If key_id is a specific key address, this should store that key

This creates a secure channel between validation and the precompile to ensure only the main key can authorize/revoke other keys. Uses transient storage, so the key is automatically cleared after the transaction.

fn load_active_key( &self, account: Address, key_id: Address, ) -> Result<AuthorizedKey>

Load and validate a key exists and is not revoked.

Returns the key if valid, or an error if:

• Key doesn’t exist (expiry == 0)
• Key has been revoked

Note: This does NOT check expiry against current timestamp. Callers should check expiry separately if needed.

pub fn validate_keychain_authorization( &self, account: Address, key_id: Address, current_timestamp: u64, ) -> Result<()>

Validate keychain authorization (existence, revocation, and expiry)

This consolidates all validation checks into one method. Returns Ok(()) if the key is valid and authorized, Err otherwise.

pub fn verify_and_update_spending( &mut self, account: Address, key_id: Address, token: Address, amount: U256, ) -> Result<()>

Internal: Verify and update spending for a token transfer

pub fn authorize_transfer( &mut self, account: Address, token: Address, amount: U256, ) -> Result<()>

Authorize a token transfer with access key spending limits

This method checks if the transaction is using an access key, and if so, verifies and updates the spending limits for that key. Should be called before executing a transfer.

Arguments

• account - The account performing the transfer
• token - The token being transferred
• amount - The amount being transferred

Returns

Ok(()) if authorized (either using main key or access key with sufficient limits) Err if unauthorized or spending limit exceeded

pub fn authorize_approve( &mut self, account: Address, token: Address, old_approval: U256, new_approval: U256, ) -> Result<()>

Authorize a token approval with access key spending limits

This method checks if the transaction is using an access key, and if so, verifies and updates the spending limits for that key. Should be called before executing an approval.

Arguments

• account - The account performing the approval
• token - The token being approved
• old_approval - The current approval amount
• new_approval - The new approval amount being set

Returns

Ok(()) if authorized (either using main key or access key with sufficient limits) Err if unauthorized or spending limit exceeded

Trait Implementations

impl ContractStorage for AccountKeychain

fn address(&self) -> Address

Contract address.

fn storage(&mut self) -> &mut StorageCtx

Contract storage accessor.

impl Default for AccountKeychain

fn default() -> Self

Returns the “default value” for a type.

impl Precompile for AccountKeychain

fn call(&mut self, calldata: &[u8], msg_sender: Address) -> PrecompileResult

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: 200 bytes