325 lines
11 KiB
Rust
325 lines
11 KiB
Rust
|
#![allow(unused)]
|
||
|
|
use coins_ledger::{
|
||
|
|
common::{APDUAnswer, APDUCommand, APDUData},
|
||
|
|
transports::{Ledger, LedgerAsync},
|
||
|
|
};
|
||
|
|
use futures_util::lock::Mutex;
|
||
|
|
|
||
|
|
use ethers_core::{
|
||
|
|
types::{
|
||
|
|
Address, NameOrAddress, Signature, Transaction, TransactionRequest, TxError, TxHash, H256,
|
||
|
|
U256,
|
||
|
|
},
|
||
|
|
utils::keccak256,
|
||
|
|
};
|
||
|
|
use std::convert::TryFrom;
|
||
|
|
use thiserror::Error;
|
||
|
|
|
||
|
|
use super::types::*;
|
||
|
|
|
||
|
|
/// A Ledger Ethereum App.
|
||
|
|
///
|
||
|
|
/// This is a simple wrapper around the [Ledger transport](Ledger)
|
||
|
|
pub struct LedgerEthereum {
|
||
|
|
transport: Mutex<Ledger>,
|
||
|
|
derivation: DerivationType,
|
||
|
|
pub chain_id: Option<u64>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl LedgerEthereum {
|
||
|
|
/// Instantiate the application by acquiring a lock on the ledger device.
|
||
|
|
///
|
||
|
|
/// # Notes
|
||
|
|
///
|
||
|
|
pub async fn new(
|
||
|
|
derivation: DerivationType,
|
||
|
|
chain_id: Option<u64>,
|
||
|
|
) -> Result<Self, LedgerError> {
|
||
|
|
Ok(Self {
|
||
|
|
transport: Mutex::new(Ledger::init().await?),
|
||
|
|
derivation,
|
||
|
|
chain_id,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Consume self and drop the ledger mutex
|
||
|
|
pub fn close(self) {}
|
||
|
|
|
||
|
|
/// Get the account which corresponds to our derivation path
|
||
|
|
pub async fn get_address(&self) -> Result<Address, LedgerError> {
|
||
|
|
self.get_address_with_path(&self.derivation).await
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Gets the account which corresponds to the provided derivation path
|
||
|
|
pub async fn get_address_with_path(
|
||
|
|
&self,
|
||
|
|
derivation: &DerivationType,
|
||
|
|
) -> Result<Address, LedgerError> {
|
||
|
|
let data = APDUData::new(&self.path_to_bytes(&derivation));
|
||
|
|
let transport = self.transport.lock().await;
|
||
|
|
|
||
|
|
let command = APDUCommand {
|
||
|
|
ins: INS::GET_PUBLIC_KEY as u8,
|
||
|
|
p1: P1::NON_CONFIRM as u8,
|
||
|
|
p2: P2::NO_CHAINCODE as u8,
|
||
|
|
data,
|
||
|
|
response_len: None,
|
||
|
|
};
|
||
|
|
|
||
|
|
let answer = transport.exchange(&command).await?;
|
||
|
|
let result = answer.data().ok_or(LedgerError::UnexpectedNullResponse)?;
|
||
|
|
|
||
|
|
let address = {
|
||
|
|
// extract the address from the response
|
||
|
|
let offset = 1 + result[0] as usize;
|
||
|
|
let address = &result[offset + 1..offset + 1 + result[offset] as usize];
|
||
|
|
std::str::from_utf8(address)?.parse::<Address>()?
|
||
|
|
};
|
||
|
|
|
||
|
|
Ok(address)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Returns the semver of the Ethereum ledger app
|
||
|
|
pub async fn version(&self) -> Result<String, LedgerError> {
|
||
|
|
let transport = self.transport.lock().await;
|
||
|
|
|
||
|
|
let command = APDUCommand {
|
||
|
|
ins: INS::GET_APP_CONFIGURATION as u8,
|
||
|
|
p1: P1::NON_CONFIRM as u8,
|
||
|
|
p2: P2::NO_CHAINCODE as u8,
|
||
|
|
data: APDUData::new(&[]),
|
||
|
|
response_len: None,
|
||
|
|
};
|
||
|
|
|
||
|
|
let answer = transport.exchange(&command).await?;
|
||
|
|
let result = answer.data().ok_or(LedgerError::UnexpectedNullResponse)?;
|
||
|
|
|
||
|
|
Ok(format!("{}.{}.{}", result[1], result[2], result[3]))
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Signs an Ethereum transaction (requires confirmation on the ledger)
|
||
|
|
// TODO: Remove code duplication between this and the PrivateKey::sign_transaction
|
||
|
|
// method
|
||
|
|
pub async fn sign_tx(
|
||
|
|
&self,
|
||
|
|
tx: TransactionRequest,
|
||
|
|
chain_id: Option<u64>,
|
||
|
|
) -> Result<Transaction, LedgerError> {
|
||
|
|
// The nonce, gas and gasprice fields must already be populated
|
||
|
|
let nonce = tx.nonce.ok_or(TxError::NonceMissing)?;
|
||
|
|
let gas_price = tx.gas_price.ok_or(TxError::GasPriceMissing)?;
|
||
|
|
let gas = tx.gas.ok_or(TxError::GasMissing)?;
|
||
|
|
|
||
|
|
let mut payload = self.path_to_bytes(&self.derivation);
|
||
|
|
payload.extend_from_slice(tx.rlp(chain_id).as_ref());
|
||
|
|
let signature = self.sign_payload(INS::SIGN, payload).await?;
|
||
|
|
|
||
|
|
// Get the actual transaction hash
|
||
|
|
let rlp = tx.rlp_signed(&signature);
|
||
|
|
let hash = keccak256(&rlp.0);
|
||
|
|
|
||
|
|
// This function should not be called with ENS names
|
||
|
|
let to = tx.to.map(|to| match to {
|
||
|
|
NameOrAddress::Address(inner) => inner,
|
||
|
|
NameOrAddress::Name(_) => {
|
||
|
|
panic!("Expected `to` to be an Ethereum Address, not an ENS name")
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
Ok(Transaction {
|
||
|
|
hash: hash.into(),
|
||
|
|
nonce,
|
||
|
|
from: self.get_address().await?,
|
||
|
|
to,
|
||
|
|
value: tx.value.unwrap_or_default(),
|
||
|
|
gas_price,
|
||
|
|
gas,
|
||
|
|
input: tx.data.unwrap_or_default(),
|
||
|
|
v: signature.v.into(),
|
||
|
|
r: U256::from_big_endian(signature.r.as_bytes()),
|
||
|
|
s: U256::from_big_endian(signature.s.as_bytes()),
|
||
|
|
|
||
|
|
// Leave these empty as they're only used for included transactions
|
||
|
|
block_hash: None,
|
||
|
|
block_number: None,
|
||
|
|
transaction_index: None,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Signs an ethereum personal message
|
||
|
|
pub async fn sign_message<S: AsRef<[u8]>>(&self, message: S) -> Result<Signature, LedgerError> {
|
||
|
|
let message = message.as_ref();
|
||
|
|
|
||
|
|
let mut payload = self.path_to_bytes(&self.derivation);
|
||
|
|
payload.extend_from_slice(&(message.len() as u32).to_be_bytes());
|
||
|
|
payload.extend_from_slice(message);
|
||
|
|
|
||
|
|
self.sign_payload(INS::SIGN_PERSONAL_MESSAGE, payload).await
|
||
|
|
}
|
||
|
|
|
||
|
|
// Helper function for signing either transaction data or personal messages
|
||
|
|
async fn sign_payload(
|
||
|
|
&self,
|
||
|
|
command: INS,
|
||
|
|
mut payload: Vec<u8>,
|
||
|
|
) -> Result<Signature, LedgerError> {
|
||
|
|
let transport = self.transport.lock().await;
|
||
|
|
let mut command = APDUCommand {
|
||
|
|
ins: command as u8,
|
||
|
|
p1: P1_FIRST,
|
||
|
|
p2: P2::NO_CHAINCODE as u8,
|
||
|
|
data: APDUData::new(&[]),
|
||
|
|
response_len: None,
|
||
|
|
};
|
||
|
|
|
||
|
|
let mut result = Vec::new();
|
||
|
|
|
||
|
|
// Iterate in 255 byte chunks
|
||
|
|
while payload.len() > 0 {
|
||
|
|
let chunk_size = std::cmp::min(payload.len(), 255);
|
||
|
|
let data = payload.drain(0..chunk_size).collect::<Vec<_>>();
|
||
|
|
command.data = APDUData::new(&data);
|
||
|
|
|
||
|
|
let answer = transport.exchange(&command).await?;
|
||
|
|
result = answer
|
||
|
|
.data()
|
||
|
|
.ok_or(LedgerError::UnexpectedNullResponse)?
|
||
|
|
.to_vec();
|
||
|
|
|
||
|
|
// We need more data
|
||
|
|
command.p1 = P1::MORE as u8;
|
||
|
|
}
|
||
|
|
|
||
|
|
let v = result[0] as u64;
|
||
|
|
let r = H256::from_slice(&result[1..33]);
|
||
|
|
let s = H256::from_slice(&result[33..]);
|
||
|
|
Ok(Signature { v, r, s })
|
||
|
|
}
|
||
|
|
|
||
|
|
// helper which converts a derivation path to bytes
|
||
|
|
fn path_to_bytes(&self, derivation: &DerivationType) -> Vec<u8> {
|
||
|
|
let derivation = derivation.to_string();
|
||
|
|
let elements = derivation.split('/').skip(1).collect::<Vec<_>>();
|
||
|
|
let depth = elements.len();
|
||
|
|
|
||
|
|
let mut bytes = vec![depth as u8];
|
||
|
|
for derivation_index in elements {
|
||
|
|
let hardened = derivation_index.contains("'");
|
||
|
|
let mut index = derivation_index.replace("'", "").parse::<u32>().unwrap();
|
||
|
|
if hardened {
|
||
|
|
index = 0x80000000 | index;
|
||
|
|
}
|
||
|
|
|
||
|
|
bytes.extend(&index.to_be_bytes());
|
||
|
|
}
|
||
|
|
|
||
|
|
bytes
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(all(test, feature = "ledger-tests"))]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
use crate::{Client, Signer};
|
||
|
|
use ethers::prelude::*;
|
||
|
|
use rustc_hex::FromHex;
|
||
|
|
use std::str::FromStr;
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
// Replace this with your ETH addresses.
|
||
|
|
async fn test_get_address() {
|
||
|
|
// Instantiate it with the default ledger derivation path
|
||
|
|
let ledger = LedgerEthereum::new(DerivationType::LedgerLive(0), None)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
assert_eq!(
|
||
|
|
ledger.get_address().await.unwrap(),
|
||
|
|
"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee".parse().unwrap()
|
||
|
|
);
|
||
|
|
assert_eq!(
|
||
|
|
ledger
|
||
|
|
.get_address_with_path(&DerivationType::Legacy(0))
|
||
|
|
.await
|
||
|
|
.unwrap(),
|
||
|
|
"eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee".parse().unwrap()
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn test_sign_tx() {
|
||
|
|
let ledger = LedgerEthereum::new(DerivationType::LedgerLive(0), None)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
// approve uni v2 router 0xff
|
||
|
|
let data = "095ea7b30000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488dffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".from_hex::<Vec<u8>>().unwrap();
|
||
|
|
|
||
|
|
let tx_req = TransactionRequest::new()
|
||
|
|
.send_to_str("2ed7afa17473e17ac59908f088b4371d28585476")
|
||
|
|
.unwrap()
|
||
|
|
.gas(1000000)
|
||
|
|
.gas_price(400e9 as u64)
|
||
|
|
.nonce(5)
|
||
|
|
.data(data)
|
||
|
|
.value(ethers_core::utils::parse_ether(100).unwrap());
|
||
|
|
let tx = ledger.sign_transaction(tx_req.clone()).await.unwrap();
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn test_send_transaction() {
|
||
|
|
let ledger = LedgerEthereum::new(DerivationType::Legacy(0), None)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
let addr = ledger.get_address().await.unwrap();
|
||
|
|
let amt = ethers_core::utils::parse_ether(10).unwrap();
|
||
|
|
let amt_with_gas = amt + U256::from_str("420000000000000").unwrap();
|
||
|
|
|
||
|
|
// fund our account
|
||
|
|
let ganache = ethers_core::utils::Ganache::new().spawn();
|
||
|
|
let provider = Provider::<Http>::try_from(ganache.endpoint()).unwrap();
|
||
|
|
let accounts = provider.get_accounts().await.unwrap();
|
||
|
|
let req = TransactionRequest::new()
|
||
|
|
.from(accounts[0])
|
||
|
|
.to(addr)
|
||
|
|
.value(amt_with_gas);
|
||
|
|
let tx = provider.send_transaction(req).await.unwrap();
|
||
|
|
assert_eq!(
|
||
|
|
provider.get_balance(addr, None).await.unwrap(),
|
||
|
|
amt_with_gas
|
||
|
|
);
|
||
|
|
|
||
|
|
// send a tx and check that it works
|
||
|
|
let client = Client::new(provider, ledger).await.unwrap();
|
||
|
|
let receiver = Address::zero();
|
||
|
|
client
|
||
|
|
.send_transaction(
|
||
|
|
TransactionRequest::new().from(addr).to(receiver).value(amt),
|
||
|
|
None,
|
||
|
|
)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
assert_eq!(client.get_balance(receiver, None).await.unwrap(), amt);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn test_version() {
|
||
|
|
let ledger = LedgerEthereum::new(DerivationType::LedgerLive(0), None)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
let version = ledger.version().await.unwrap();
|
||
|
|
assert_eq!(version, "1.3.7");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn test_sign_message() {
|
||
|
|
let ledger = LedgerEthereum::new(DerivationType::Legacy(0), None)
|
||
|
|
.await
|
||
|
|
.unwrap();
|
||
|
|
let message = "hello world";
|
||
|
|
let sig = ledger.sign_message(message).await.unwrap();
|
||
|
|
let addr = ledger.get_address().await.unwrap();
|
||
|
|
sig.verify(message, addr).unwrap();
|
||
|
|
}
|
||
|
|
}
|