Struct ethers_signers::Ledger

pub struct Ledger { /* fields omitted */ }

A Ledger Ethereum App.

This is a simple wrapper around the Ledger transport

Implementations

impl LedgerEthereum

pub async fn new(
    derivation: DerivationType,
    chain_id: u64
) -> Result<Self, LedgerError>

Instantiate the application by acquiring a lock on the ledger device.

use ethers_signers::{Ledger, HDPath};

let ledger = Ledger::new(HDPath::LedgerLive(0), 1).await?;

pub fn close(self)

Consume self and drop the ledger mutex

pub async fn get_address(&self) -> Result<Address, LedgerError>

Get the account which corresponds to our derivation path

pub async fn get_address_with_path(
    &self,
    derivation: &DerivationType
) -> Result<Address, LedgerError>

Gets the account which corresponds to the provided derivation path

pub async fn version(&self) -> Result<String, LedgerError>

Returns the semver of the Ethereum ledger app

pub async fn sign_tx(
    &self,
    tx: &TypedTransaction
) -> Result<Signature, LedgerError>

Signs an Ethereum transaction (requires confirmation on the ledger)

pub async fn sign_message<S: AsRef<[u8]>>(
    &self,
    message: S
) -> Result<Signature, LedgerError>

Signs an ethereum personal message

pub async fn sign_typed_struct<T>(
    &self,
    payload: &T
) -> Result<Signature, LedgerError> where
    T: Eip712, 

Signs an EIP712 encoded domain separator and message

pub async fn sign_payload(
    &self,
    command: INS,
    payload: Vec<u8>
) -> Result<Signature, LedgerError>

Trait Implementations

impl Debug for LedgerEthereum

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

Formats the value using the given formatter.

impl Signer for LedgerEthereum

fn sign_message<'life0, 'async_trait, S: Send + Sync + AsRef<[u8]>>(
    &'life0 self,
    message: S
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Signs the hash of the provided message after prefixing it

fn sign_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    message: &'life1 TypedTransaction
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Signs the transaction

fn sign_typed_data<'life0, 'life1, 'async_trait, T: Eip712 + Send + Sync>(
    &'life0 self,
    payload: &'life1 T
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Signs a EIP712 derived struct

fn address(&self) -> Address

Returns the signer’s Ethereum Address

type Error = LedgerError

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

Sets the signer’s chain id

fn chain_id(&self) -> u64

Returns the signer’s chain id