Commit 2659346

- [ ] [Ledger signer](./examples/wallets/examples/ledger_signer.rs)

- [ ] [Private key signer](./examples/wallets/examples/private_key_signer.rs)

- [ ] [Mnemonic signer](./examples/wallets/examples/mnemonic_signer.rs)

- [ ] [Sign message](./examples/wallets/examples/sign_message.rs)

- [ ] [Sign permit hash](./examples/wallets/examples/sign_permit_hash.rs)

- [ ] [Trezor signer](./examples/wallets/examples/trezor_signer.rs)

- [ ] [Yubi signer](./examples/wallets/examples/yubi_signer.rs)

[package]

name = "examples-wallets"

version.workspace = true

edition.workspace = true

rust-version.workspace = true

authors.workspace = true

license.workspace = true

homepage.workspace = true

repository.workspace = true

exclude.workspace = true

publish.workspace = true

[dev-dependencies]

alloy-network.workspace = true

alloy-node-bindings.workspace = true

alloy-primitives.workspace = true

alloy-provider.workspace = true

alloy-rpc-client.workspace = true

alloy-rpc-types.workspace = true

alloy-signer = { workspace = true, features = [

"eip712",

"mnemonic",

"yubihsm",

] }

alloy-signer-ledger.workspace = true

alloy-signer-trezor.workspace = true

alloy-sol-types.workspace = true

alloy-transport-http.workspace = true

coins-bip39.workspace = true

rand.workspace = true

reqwest.workspace = true

serde.workspace = true

tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

use alloy_network::{Ethereum, EthereumSigner};

use alloy_primitives::{address, U256};

use alloy_provider::{Provider, ProviderBuilder, RootProvider};

use alloy_rpc_client::RpcClient;

use alloy_rpc_types::request::TransactionRequest;

use alloy_signer_ledger::{HDPath, LedgerSigner};

use alloy_transport_http::Http;

use reqwest::Client;

async fn main() -> Result<(), Box<dyn std::error::Error>> {

// Instantiate the application by acquiring a lock on the Ledger device.

let signer = LedgerSigner::new(HDPath::LedgerLive(0), Some(1)).await?;

// Create a provider with the signer and the network.

let http = Http::<Client>::new("http://localhost:8545".parse()?);

let provider = ProviderBuilder::<_, Ethereum>::new()

.signer(EthereumSigner::from(signer))

.network::<Ethereum>()

.provider(RootProvider::new(RpcClient::new(http, true)));

// Create a transaction.

let tx = TransactionRequest {

value: Some(U256::from(100)),

to: address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045").into(),

gas_price: Some(U256::from(20e9)),

gas: Some(U256::from(21000)),

..Default::default()

};

// Broadcast the transaction and wait for the receipt.

let receipt = provider.send_transaction(tx).await?.with_confirmations(3).get_receipt().await?;

println!("Send transaction: {:?}", receipt.transaction_hash.unwrap());

Ok(())

use alloy_signer::MnemonicBuilder;

use coins_bip39::English;

async fn main() -> Result<(), Box<dyn std::error::Error>> {

let phrase = "work man father plunge mystery proud hollow address reunion sauce theory bonus";

let index = 0u32;

let password = "TREZOR123";

// Access mnemonic phrase with password

// Child key at derivation path: m/44'/60'/0'/0/{index}

let wallet = MnemonicBuilder::<English>::default()

.phrase(phrase)

.index(index)?

// Use this if your mnemonic is encrypted

.password(password)

.build()?;

println!("Wallet: {:?}", wallet);

// Generate a random wallet (24 word phrase) at custom derivation path

let mut rng = rand::thread_rng();

let wallet = MnemonicBuilder::<English>::default()

.word_count(24)

.derivation_path("m/44'/60'/0'/2/1")?

// Optionally add this if you want the generated mnemonic to be written

// to a file

// .write_to(path)

.build_random(&mut rng)?;

println!("Random wallet: {:?}", wallet);

Ok(())

use alloy_network::{Ethereum, EthereumSigner};

use alloy_node_bindings::Anvil;

use alloy_primitives::{U256, U64};

use alloy_provider::{Provider, ProviderBuilder, RootProvider};

use alloy_rpc_client::RpcClient;

use alloy_rpc_types::request::TransactionRequest;

use alloy_signer::LocalWallet;

use alloy_transport_http::Http;

use reqwest::Client;

async fn main() -> Result<(), Box<dyn std::error::Error>> {

// Spin up an Anvil node.

let anvil = Anvil::new().block_time(1).spawn();

// Set up the wallets.

let alice: LocalWallet = anvil.keys()[0].clone().into();

let bob: LocalWallet = anvil.keys()[1].clone().into();

// Create a provider with a signer and the network.

let http = Http::<Client>::new(anvil.endpoint().parse()?);

let provider = ProviderBuilder::<_, Ethereum>::new()

.signer(EthereumSigner::from(alice))

.network::<Ethereum>()

.provider(RootProvider::new(RpcClient::new(http, true)));

// Create a transaction.

let tx = TransactionRequest {

value: Some(U256::from(100)),

to: Some(bob.address()),

nonce: Some(U64::from(0)),

gas_price: Some(U256::from(20e9)),

gas: Some(U256::from(21000)),

..Default::default()

};

// Broadcast the transaction and wait for the receipt.

let receipt = provider.send_transaction(tx).await?.with_confirmations(1).get_receipt().await?;

println!("Send transaction: {:?}", receipt.transaction_hash.unwrap());

Ok(())

use alloy_signer::{LocalWallet, Signer};

async fn main() -> Result<(), Box<dyn std::error::Error>> {

// Setup up wallet.

let wallet = LocalWallet::random();

// Optionally, the wallet's chain id can be set, in order to use EIP-155

// replay protection with different chains

let wallet = wallet.with_chain_id(Some(1337));

// The message to sign.

let message = b"hello";

// Sign the message asynchronously with the wallet.

let signature = wallet.sign_message(message).await?;

println!("Signature produced by {:?}: {:?}", wallet.address(), signature);

println!(

"Signature recovered address: {:?}",

signature.recover_address_from_msg(&message[..]).unwrap()

);

Ok(())

use alloy_primitives::{address, keccak256, U256};

use alloy_signer::{LocalWallet, Signer};

use alloy_sol_types::{eip712_domain, sol, SolStruct};

use serde::Serialize;

sol! {

#[derive(Debug, Serialize)]

struct Permit {

address owner;

address spender;

uint256 value;

uint256 nonce;

uint256 deadline;

}

async fn main() -> Result<(), Box<dyn std::error::Error>> {

// Setup up wallet.

let wallet = LocalWallet::random();

let domain = eip712_domain! {

name: "Uniswap V2",

version: "1",

chain_id: 1,

verifying_contract: address!("B4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc"),

salt: keccak256("test"),

};

let permit = Permit {

owner: wallet.address(),

spender: address!("B4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc"),

value: U256::from(100),

nonce: U256::from(0),

deadline: U256::from(0),

};

// Derive the EIP-712 signing hash.

let hash = permit.eip712_signing_hash(&domain);

// Sign the hash asynchronously with the wallet.

let signature = wallet.sign_typed_data(&permit, &domain).await?;

println!(

"Recovered address matches wallet address: {:?}",

signature.recover_address_from_prehash(&hash)? == wallet.address()

);

println!("Wallet signature matches: {:?}", wallet.sign_hash(&hash).await? == signature);

Ok(())

use alloy_network::{Ethereum, EthereumSigner};

use alloy_primitives::{address, U256};

use alloy_provider::{Provider, ProviderBuilder, RootProvider};

use alloy_rpc_client::RpcClient;

use alloy_rpc_types::request::TransactionRequest;

use alloy_signer_trezor::{TrezorHDPath, TrezorSigner};

use alloy_transport_http::Http;

use reqwest::Client;

async fn main() -> Result<(), Box<dyn std::error::Error>> {

// Instantiate the application by acquiring a lock on the Trezor device.

let signer = TrezorSigner::new(TrezorHDPath::TrezorLive(0), Some(1)).await?;

// Create a provider with the signer and the network.

let http = Http::<Client>::new("http://localhost:8545".parse()?);

let provider = ProviderBuilder::<_, Ethereum>::new()

.signer(EthereumSigner::from(signer))

.network::<Ethereum>()

.provider(RootProvider::new(RpcClient::new(http, true)));

// Create a transaction.

let tx = TransactionRequest {

value: Some(U256::from(100)),

to: address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045").into(),

gas_price: Some(U256::from(20e9)),

gas: Some(U256::from(21000)),

..Default::default()

};

// Broadcast the transaction and wait for the receipt.

let receipt = provider.send_transaction(tx).await?.with_confirmations(3).get_receipt().await?;

println!("Send transaction: {:?}", receipt.transaction_hash.unwrap());

Ok(())