Struct LocalSigner

pub struct LocalSigner<C> { /* private fields */ }

An Ethereum private-public key pair which can be used for signing messages.

Examples

Signing and Verifying a message

The signer can be used to produce ECDSA Signature objects, which can be then verified. Note that this uses eip191_hash_message under the hood which will prefix the message being hashed with the Ethereum Signed Message domain separator.

use alloy_signer::{Signer, SignerSync};
use alloy_signer_local::PrivateKeySigner;

let signer = PrivateKeySigner::random();

// Optionally, the signer's chain id can be set, in order to use EIP-155
// replay protection with different chains
let signer = signer.with_chain_id(Some(1337));

// The signer can be used to sign messages
let message = b"hello";
let signature = signer.sign_message_sync(message)?;
assert_eq!(signature.recover_address_from_msg(&message[..]).unwrap(), signer.address());

// LocalSigner is cloneable:
let signer_clone = signer.clone();
let signature2 = signer_clone.sign_message_sync(message)?;
assert_eq!(signature, signature2);

Implementations

impl LocalSigner<SigningKey>

pub fn from_signing_key(credential: SigningKey) -> Self

Creates a new LocalSigner instance from a SigningKey.

This can also be used to create a LocalSigner from a SecretKey. See also the From implementations.

pub fn from_bytes(bytes: &B256) -> Result<Self, Error>

Creates a new LocalSigner instance from a raw scalar serialized as a B256 byte array.

This is identical to from_field_bytes.

pub fn from_field_bytes(bytes: &FieldBytes) -> Result<Self, Error>

Creates a new LocalSigner instance from a raw scalar serialized as a FieldBytes byte array.

pub fn from_slice(bytes: &[u8]) -> Result<Self, Error>

Creates a new LocalSigner instance from a raw scalar serialized as a byte slice.

Byte slices shorter than the field size (32 bytes) are handled by zero padding the input.

pub fn random() -> Self

Creates a new random keypair seeded with rand::thread_rng().

pub fn random_with<R: Rng + CryptoRng>(rng: &mut R) -> Self

Creates a new random keypair seeded with the provided RNG.

pub fn as_nonzero_scalar(&self) -> &NonZeroScalar

Borrow the secret NonZeroScalar value for this key.

⚠️ Warning

This value is key material.

Please treat it with the care it deserves!

pub fn to_bytes(&self) -> B256

Serialize this LocalSigner’s SigningKey as a B256 byte array.

pub fn to_field_bytes(&self) -> FieldBytes

Serialize this LocalSigner’s SigningKey as a FieldBytes byte array.

impl LocalSigner<SigningKey>

pub fn new_keystore<P, R, S>( dir: P, rng: &mut R, password: S, name: Option<&str>, ) -> Result<(Self, String), LocalSignerError>

where P: AsRef<Path>, R: Rng + CryptoRng, S: AsRef<[u8]>,

Available on crate feature keystore only.

Creates a new random encrypted JSON with the provided password and stores it in the provided directory. Returns a tuple (LocalSigner, String) of the signer instance for the keystore with its random UUID. Accepts an optional name for the keystore file. If None, the keystore is stored as the stringified UUID.

pub fn decrypt_keystore<P, S>( keypath: P, password: S, ) -> Result<Self, LocalSignerError>

where P: AsRef<Path>, S: AsRef<[u8]>,

Available on crate feature keystore only.

Decrypts an encrypted JSON from the provided path to construct a LocalSigner instance

pub fn encrypt_keystore<P, R, B, S>( keypath: P, rng: &mut R, pk: B, password: S, name: Option<&str>, ) -> Result<(Self, String), LocalSignerError>

where P: AsRef<Path>, R: Rng + CryptoRng, B: AsRef<[u8]>, S: AsRef<[u8]>,

Available on crate feature keystore only.

Creates a new encrypted JSON with the provided private key and password and stores it in the provided directory. Returns a tuple (LocalSigner, String) of the signer instance for the keystore with its random UUID. Accepts an optional name for the keystore file. If None, the keystore is stored as the stringified UUID.

impl LocalSigner<Signer<Secp256k1>>

pub fn connect(connector: Connector, credentials: Credentials, id: Id) -> Self

Available on crate feature yubihsm only.

Connects to a yubi key’s ECDSA account at the provided id

pub fn new( connector: Connector, credentials: Credentials, id: Id, label: Label, domain: Domain, ) -> Self

Available on crate feature yubihsm only.

Creates a new random ECDSA keypair on the yubi at the provided id

pub fn from_key( connector: Connector, credentials: Credentials, id: Id, label: Label, domain: Domain, key: impl Into<Vec<u8>>, ) -> Self

Available on crate feature yubihsm only.

Uploads the provided keypair on the yubi at the provided id

impl<C: PrehashSigner<(Signature, RecoveryId)>> LocalSigner<C>

pub const fn new_with_credential( credential: C, address: Address, chain_id: Option<ChainId>, ) -> Self

Construct a new credential with an external PrehashSigner.

pub const fn credential(&self) -> &C

Returns this signer’s credential.

pub fn into_credential(self) -> C

Consumes this signer and returns its credential.

pub const fn address(&self) -> Address

Returns this signer’s address.

pub const fn chain_id(&self) -> Option<ChainId>

Returns this signer’s chain ID.

Trait Implementations

impl<C: Clone> Clone for LocalSigner<C>

fn clone(&self) -> LocalSigner<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: PrehashSigner<(Signature, RecoveryId)>> Debug for LocalSigner<C>

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

Formats the value using the given formatter.

impl From<SecretKey<Secp256k1>> for LocalSigner<SigningKey>

fn from(value: K256SecretKey) -> Self

Converts to this type from the input type.

impl From<Signer<Secp256k1>> for LocalSigner<Signer<Secp256k1>>

Available on crate feature yubihsm only.

fn from(credential: YubiSigner<Secp256k1>) -> Self

Converts to this type from the input type.

impl From<SigningKey<Secp256k1>> for LocalSigner<SigningKey>

fn from(value: SigningKey) -> Self

Converts to this type from the input type.

impl FromStr for LocalSigner<SigningKey>

type Err = LocalSignerError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for LocalSigner<SigningKey>

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<C: PrehashSigner<(Signature, RecoveryId)> + Send + Sync> Signer for LocalSigner<C>

fn sign_hash<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 B256, ) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Signs the given hash.

fn address(&self) -> Address

Returns the signer’s Ethereum Address.

fn chain_id(&self) -> Option<ChainId>

Returns the signer’s chain ID.

fn set_chain_id(&mut self, chain_id: Option<ChainId>)

Sets the signer’s chain ID.

fn sign_message<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Sig, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Signs the hash of the provided message after prefixing it, as specified in EIP-191.

fn sign_typed_data<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, payload: &'life1 T, domain: &'life2 Eip712Domain, ) -> Pin<Box<dyn Future<Output = Result<Sig, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sized + Sync + 'async_trait, T: 'async_trait + SolStruct + Send + Sync,

Available on crate feature eip712 only.

Encodes and signs the typed data according to EIP-712.

fn sign_dynamic_typed_data<'life0, 'life1, 'async_trait>( &'life0 self, payload: &'life1 TypedData, ) -> Pin<Box<dyn Future<Output = Result<Sig, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Available on crate feature eip712 only.

Encodes and signs the typed data according to [EIP-712] for Signers that are not dynamically sized.

fn with_chain_id(self, chain_id: Option<u64>) -> Self

where Self: Sized,

Sets the signer’s chain ID and returns self.

impl<C: PrehashSigner<(Signature, RecoveryId)>> SignerSync for LocalSigner<C>

fn sign_hash_sync(&self, hash: &B256) -> Result<Signature>

Signs the given hash.

fn chain_id_sync(&self) -> Option<ChainId>

Returns the signer’s chain ID.

fn sign_message_sync(&self, message: &[u8]) -> Result<Sig, Error>

Signs the hash of the provided message after prefixing it, as specified in EIP-191.

fn sign_typed_data_sync<T>( &self, payload: &T, domain: &Eip712Domain, ) -> Result<Sig, Error>

where T: SolStruct, Self: Sized,

Available on crate feature eip712 only.

Encodes and signs the typed data according to EIP-712.

fn sign_dynamic_typed_data_sync( &self, payload: &TypedData, ) -> Result<Sig, Error>

Available on crate feature eip712 only.

Encodes and signs the typed data according to EIP-712 for Signers that are not dynamically sized.

impl<C> TxSigner<Signature> for LocalSigner<C>

where C: PrehashSigner<(Signature, RecoveryId)> + Send + Sync,

fn address(&self) -> Address

Get the address of the signer.

fn sign_transaction<'life0, 'life1, 'async_trait>( &'life0 self, tx: &'life1 mut dyn SignableTransaction<Signature>, ) -> Pin<Box<dyn Future<Output = Result<Signature>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously sign an unsigned transaction.

impl<C> TxSignerSync<Signature> for LocalSigner<C>

where C: PrehashSigner<(Signature, RecoveryId)>,

fn address(&self) -> Address

Get the address of the signer.

fn sign_transaction_sync( &self, tx: &mut dyn SignableTransaction<Signature>, ) -> Result<Signature>

Synchronously sign an unsigned transaction.