test: ledger integration test (xJonathanLEI#734)

Author: xJonathanLEI

.github/workflows/test.yaml

@@ -151,3 +151,21 @@ jobs:
           cargo build --package starknet-core \
             --target thumbv6m-none-eabi \
             --no-default-features
+
+  ledger:
+    name: Ledger tests
+    runs-on: ubuntu-latest
+    container: ghcr.io/ledgerhq/ledger-app-builder/ledger-app-dev-tools
+
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+
+      - name: Install stable Rust toolchain
+        run: |
+          rustup toolchain install stable
+
+      - name: Run tests
+        run: |
+          cargo test --package starknet-signers \
+            -- --ignored

Cargo.lock

@@ -30,6 +30,13 @@ eth-keystore = { version = "0.5.0", default-features = false }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.9", features = ["js"] }
 
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+starknet-signers = { path = ".", features = ["ledger"] }
+hex = { version = "0.4.3", default-features = false, features = ["alloc", "serde"] }
+serde = { version = "1.0.160", features = ["derive"] }
+reqwest = { version = "0.12.15", default-features = false, features = ["json"] }
+tokio = { version = "1.27.0", features = ["full"] }
+
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wasm-bindgen-test = "0.3.50"
 

starknet-signers/Cargo.toml

@@ -33,8 +33,8 @@ pub struct LedgerSigner {
 
 /// A handle for communicating with the Ledger Starknet app.
 #[derive(Debug)]
-pub struct LedgerStarknetApp {
-    transport: Ledger,
+pub struct LedgerStarknetApp<T = Ledger> {
+    transport: T,
 }
 
 /// Errors using the Ledger hardware wallet.
@@ -133,11 +133,21 @@ impl Signer for LedgerSigner {
     }
 }
 
-impl LedgerStarknetApp {
+impl<T> LedgerStarknetApp<T> {
+    /// Creates Starknet Ledger app handle using an already-initialized transport.
+    pub fn from_transport(transport: T) -> Self {
+        Self { transport }
+    }
+}
+
+impl<T> LedgerStarknetApp<T>
+where
+    T: LedgerAsync,
+{
     /// Initializes the Starknet Ledger app. Attempts to find and connect to a Ledger device. The
     /// device must be unlocked and have the Starknet app open.
     pub async fn new() -> Result<Self, LedgerError> {
-        let transport = Ledger::init().await?;
+        let transport = T::init().await?;
 
         Ok(Self { transport })
     }

starknet-signers/src/ledger.rs

@@ -0,0 +1,121 @@
+#![cfg(not(target_arch = "wasm32"))]
+
+use std::{
+    process::{Child, Command},
+    time::Duration,
+};
+
+use async_trait::async_trait;
+use coins_ledger::{transports::LedgerAsync, APDUAnswer, APDUCommand, LedgerError};
+use reqwest::{Client, ClientBuilder};
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use starknet_core::types::Felt;
+use starknet_signers::ledger::LedgerStarknetApp;
+
+const TEST_PATH: &str = "m/2645'/1195502025'/1470455285'/0'/0'/0";
+
+#[derive(Debug)]
+struct SpeculosTransport {
+    process: Child,
+    port: u16,
+    client: Client,
+}
+
+#[derive(Serialize, Deserialize)]
+struct ApduData {
+    #[serde(with = "hex")]
+    data: Vec<u8>,
+}
+
+impl SpeculosTransport {
+    async fn new(port: u16) -> Self {
+        let mut cmd = Command::new("speculos");
+        let process = cmd
+            .args([
+                "--api-port",
+                &port.to_string(),
+                "--apdu-port",
+                "0",
+                "-m",
+                "nanox",
+                "--display",
+                "headless",
+                "./test-data/ledger-app/nanox_2.4.2_2.3.1_sdk_v22.10.0",
+            ])
+            .spawn()
+            .expect("Unable to spawn speculos process");
+
+        // Wait for process to be ready (flaky)
+        tokio::time::sleep(Duration::from_secs(1)).await;
+
+        Self {
+            process,
+            port,
+            client: ClientBuilder::new()
+                .timeout(Duration::from_secs(10))
+                .build()
+                .unwrap(),
+        }
+    }
+
+    async fn send(&self, packet: &APDUCommand) -> Result<APDUAnswer, LedgerError> {
+        let response = self
+            .client
+            .post(format!("http://localhost:{}/apdu", self.port))
+            .json(&ApduData {
+                data: packet.serialize(),
+            })
+            .send()
+            .await
+            .unwrap();
+
+        let body = response.json::<ApduData>().await.unwrap();
+        APDUAnswer::from_answer(body.data)
+    }
+}
+
+#[async_trait]
+impl LedgerAsync for SpeculosTransport {
+    async fn init() -> Result<Self, LedgerError> {
+        Ok(Self::new(5001).await)
+    }
+
+    async fn exchange(&self, packet: &APDUCommand) -> Result<APDUAnswer, LedgerError> {
+        self.send(packet).await
+    }
+
+    fn close(self) {}
+}
+
+impl Drop for SpeculosTransport {
+    fn drop(&mut self) {
+        let _ = self.process.kill();
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires Speculos installation"]
+async fn test_get_app_version() {
+    let app = LedgerStarknetApp::from_transport(SpeculosTransport::new(5001).await);
+    let version = app.get_version().await.unwrap();
+
+    assert_eq!(version, Version::new(2, 3, 1));
+}
+
+#[tokio::test]
+#[ignore = "requires Speculos installation"]
+async fn test_get_public_key_headless() {
+    let app = LedgerStarknetApp::from_transport(SpeculosTransport::new(5002).await);
+    let public_key = app
+        .get_public_key(TEST_PATH.parse().unwrap(), false)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        public_key.scalar(),
+        Felt::from_hex_unchecked(
+            "0x07427aa749c4fc98a5bf76f037eb3c61e7b4793b576a72d45a4b52c5ded997f2"
+        )
+    );
+}