Struct KeychainSignature 

pub struct KeychainSignature {
    pub user_address: Address,
    pub signature: PrimitiveSignature,
    pub version: KeychainVersion,
    cached_key_id: OnceLock<Address>,
}

Keychain signature wrapping another signature with a user address. This allows an access key to sign on behalf of a root account.

No Compact impl — always wrapped in TempoSignature whose Compact delegates to to_bytes()/from_bytes() which encodes the version via the wire type byte (0x03 = V1, 0x04 = V2).

Format (V1): 0x03 || user_address (20 bytes) || inner_signature Format (V2): 0x04 || user_address (20 bytes) || inner_signature

The user_address is the root account this transaction is being executed for. The inner signature proves an authorized access key signed the transaction. The handler validates that user_address has authorized the access key in the KeyChain precompile.

Fields

user_address: Address

Root account address that this transaction is being executed for

signature: PrimitiveSignature

The actual signature from the access key (can be Secp256k1, P256, or WebAuthn, but NOT another Keychain)

version: KeychainVersion

Keychain signature version (V1 = legacy, V2 = includes user_address in sig hash)

cached_key_id: OnceLock<Address>

Cached access key ID recovered from the inner signature. This is an implementation detail - use key_id() to access. Uses OnceLock for thread-safe interior mutability. Note: Excluded from PartialEq, Eq, Hash, and Compact as it’s a cache.

Implementations

impl KeychainSignature

pub fn new(user_address: Address, signature: PrimitiveSignature) -> Self

Create a new V2 KeychainSignature (recommended).

V2 signatures include the user_address in the signature hash.

pub fn new_v1(user_address: Address, signature: PrimitiveSignature) -> Self

Create a legacy V1 KeychainSignature.

V1 signatures do NOT include the user_address in the signature hash and are deprecated at the T1C hardfork.

fn effective_sig_hash(&self, sig_hash: &B256) -> B256

Compute the effective signature hash for key recovery.

• V1: returns sig_hash directly (legacy, deprecated)
• V2: returns keccak256(0x04 || sig_hash || user_address)

pub fn key_id(&self, sig_hash: &B256) -> Result<Address, RecoveryError>

Get the access key ID for Keychain signatures.

For Keychain signatures, this returns the access key address that signed the transaction. The key_id is recovered from the inner signature on first access and cached for subsequent calls. Returns None for non-Keychain signatures.

This follows the pattern used in alloy for lazy hash computation.

pub fn is_legacy(&self) -> bool

Returns true if this is a legacy V1 keychain signature.

pub fn signing_hash(sig_hash: B256, user_address: Address) -> B256

Compute the hash that an access key should sign for a V2 keychain transaction.

Returns keccak256(0x04 || sig_hash || user_address). The 0x04 domain separator (SIGNATURE_TYPE_KEYCHAIN_V2) prevents cross-scheme signature confusion, following the same pattern as EIP-7702 (0x05) and Tempo fee-payer signatures (0x78).

Trait Implementations

impl<'a> Arbitrary<'a> for KeychainSignature

Available on crate features arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for KeychainSignature

fn clone(&self) -> KeychainSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeychainSignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeychainSignature

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for KeychainSignature

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for KeychainSignature

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 Serialize for KeychainSignature

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for KeychainSignature

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