Async and support TAPSIGNER backup and change commands, sign PSBT

cli/Cargo.toml

@@ -10,6 +10,7 @@ rust-cktap = { path = "../lib", features = ["pcsc"] }
 pcsc = { version = "2" }
 clap = { version = "4.3.1", features = ["derive"] }
 rpassword = { version = "7.2" }
+tokio = { version = "1", features = ["full"] }
 
 [features]
 emulator = ["rust-cktap/emulator"]

cli/src/main.rs

@@ -65,16 +65,21 @@ enum TapSignerCommand {
         #[clap(short, long, value_delimiter = ',', num_args = 1..)]
         path: Vec<u32>,
     },
+    /// Get a an encrypted backup of the card's private key
+    Backup,
+    /// Change the PIN (CVC) used for card authentication to a new user provided one
+    Change { new_cvc: String },
 }
 
-fn main() -> Result<(), Error> {
+#[tokio::main]
+async fn main() -> Result<(), Error> {
     // figure out what type of card we have before parsing cli args
     #[cfg(not(feature = "emulator"))]
-    let mut card = pcsc::find_first()?;
+    let mut card = pcsc::find_first().await?;
 
     // if emulator feature enabled override pcsc card
     #[cfg(feature = "emulator")]
-    let mut card = emulator::find_emulator()?;
+    let mut card = emulator::find_emulator().await?;
 
     let rng = &mut rand::thread_rng();
 
@@ -86,21 +91,21 @@ fn main() -> Result<(), Error> {
                     dbg!(&sc);
                 }
                 SatsCardCommand::Address => println!("Address: {}", sc.address().unwrap()),
-                SatsCardCommand::Certs => check_cert(sc),
-                SatsCardCommand::Read => read(sc, None),
+                SatsCardCommand::Certs => check_cert(sc).await,
+                SatsCardCommand::Read => read(sc, None).await,
                 SatsCardCommand::New => {
                     let slot = sc.slot().expect("current slot number");
-                    let chain_code = Some(rand_chaincode(rng).to_vec());
-                    let response = &sc.new_slot(slot, chain_code, cvc()).unwrap();
+                    let chain_code = Some(rand_chaincode(rng));
+                    let response = &sc.new_slot(slot, chain_code, &cvc()).await.unwrap();
                     println!("{}", response)
                 }
                 SatsCardCommand::Unseal => {
                     let slot = sc.slot().expect("current slot number");
-                    let response = &sc.unseal(slot, cvc()).unwrap();
+                    let response = &sc.unseal(slot, &cvc()).await.unwrap();
                     println!("{}", response)
                 }
                 SatsCardCommand::Derive => {
-                    dbg!(&sc.derive());
+                    dbg!(&sc.derive().await);
                 }
             }
         }
@@ -110,15 +115,25 @@ fn main() -> Result<(), Error> {
                 TapSignerCommand::Debug => {
                     dbg!(&ts);
                 }
-                TapSignerCommand::Certs => check_cert(ts),
-                TapSignerCommand::Read => read(ts, Some(cvc())),
+                TapSignerCommand::Certs => check_cert(ts).await,
+                TapSignerCommand::Read => read(ts, Some(cvc())).await,
                 TapSignerCommand::Init => {
-                    let chain_code = rand_chaincode(rng).to_vec();
-                    let response = &ts.init(chain_code, cvc());
+                    let chain_code = rand_chaincode(rng);
+                    let response = &ts.init(chain_code, &cvc()).await;
                     dbg!(response);
                 }
                 TapSignerCommand::Derive { path } => {
-                    dbg!(&ts.derive(path, cvc()));
+                    dbg!(&ts.derive(&path, &cvc()).await);
+                }
+
+                TapSignerCommand::Backup => {
+                    let response = &ts.backup(&cvc()).await;
+                    println!("{:?}", response);
+                }
+
+                TapSignerCommand::Change { new_cvc } => {
+                    let response = &ts.change(&new_cvc, &cvc()).await;
+                    println!("{:?}", response);
                 }
             }
         }
@@ -129,8 +144,11 @@ fn main() -> Result<(), Error> {
 
 // handler functions for each command
 
-fn check_cert<T: CkTransport>(card: &mut dyn Certificate<T>) {
-    if let Ok(k) = card.check_certificate() {
+async fn check_cert<C, T: CkTransport>(card: &mut C)
+where
+    C: Certificate<T>,
+{
+    if let Ok(k) = card.check_certificate().await {
         println!(
             "Genuine card from Coinkite.\nHas cert signed by: {}",
             k.name()
@@ -140,8 +158,11 @@ fn check_cert<T: CkTransport>(card: &mut dyn Certificate<T>) {
     }
 }
 
-fn read<T: CkTransport>(card: &mut dyn Read<T>, cvc: Option<String>) {
-    match card.read(cvc) {
+async fn read<C, T: CkTransport>(card: &mut C, cvc: Option<String>)
+where
+    C: Read<T>,
+{
+    match card.read(cvc).await {
         Ok(resp) => println!("{}", resp),
         Err(e) => {
             dbg!(&e);

lib/Cargo.toml

@@ -13,15 +13,18 @@ name = "rust_cktap"
 ciborium = "0.2.0"
 serde = "1"
 serde_bytes = "0.11"
-secp256k1 = { version = "0.26.0", features = ["rand-std", "bitcoin-hashes-std", "recovery"] }
+secp256k1 = { version = "0.30.0", features = ["recovery", "std", "hashes", "rand"] }
+
+# async
+tokio = { version = "1.44", features = ["macros"] }
 
 # optional dependencies
 pcsc = { version = "2", optional = true }
-uniffi = { version = "=0.28.0", features = ["cli"] }
-thiserror = "1.0.58"
+uniffi = { version = "=0.29.0", features = ["cli"] }
+thiserror = "2.0"
 
 [build-dependencies]
-uniffi = { version = "=0.28.0", features = ["build"] }
+uniffi = { version = "=0.29.0", features = ["build"] }
 
 [features]
 default = []

lib/examples/pcsc.rs

@@ -17,8 +17,9 @@ fn get_cvc() -> String {
 }
 
 // Example using pcsc crate
-fn main() -> Result<(), Error> {
-    let card = pcsc::find_first()?;
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    let card = pcsc::find_first().await?;
     dbg!(&card);
 
     let rng = &mut rand::thread_rng();
@@ -30,25 +31,25 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while ts.auth_delay.is_some() {
                 dbg!(ts.auth_delay.unwrap());
-                ts.wait(None)?;
+                ts.wait(None).await?;
             }
 
             // only do this once per card!
             if ts.path.is_none() {
-                let chain_code = rand_chaincode(rng).to_vec();
-                let new_result = ts.init(chain_code, cvc)?;
+                let chain_code = rand_chaincode(rng);
+                let new_result = ts.init(chain_code, &cvc).await.unwrap();
                 dbg!(new_result);
             }
 
-            // let read_result = card.read(cvc.clone())?;
+            // let read_result = ts.read(Some(cvc.clone())).await?;
             // dbg!(read_result);
 
-            dbg!(ts.check_certificate().unwrap().name());
+            dbg!(ts.check_certificate().await.unwrap().name());
 
             //let dump_result = card.dump();
 
             // let path = vec![2147483732, 2147483648, 2147483648];
-            // let derive_result = card.derive(path, cvc.clone())?;
+            // let derive_result = ts.derive(path, cvc.clone()).await?;
             // dbg!(&derive_result);
 
             // let nfc_result = card.nfc()?;
@@ -60,17 +61,17 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while chip.auth_delay.is_some() {
                 dbg!(chip.auth_delay.unwrap());
-                chip.wait(None)?;
+                chip.wait(None).await?;
             }
 
             // only do this once per card!
             if chip.path.is_none() {
-                let chain_code = rand_chaincode(rng).to_vec();
-                let new_result = chip.init(chain_code, get_cvc())?;
+                let chain_code = rand_chaincode(rng);
+                let new_result = chip.init(chain_code, &get_cvc()).await.unwrap();
                 dbg!(new_result);
             }
 
-            // let read_result = card.read(cvc)?;
+            // let read_result = chip.read(Some(cvc.clone())).await?;
             // dbg!(read_result);
 
             // let nfc_result = card.nfc()?;
@@ -80,17 +81,17 @@ fn main() -> Result<(), Error> {
             // if auth delay call wait
             while sc.auth_delay.is_some() {
                 dbg!(sc.auth_delay.unwrap());
-                let wait_response = sc.wait(None)?;
+                let wait_response = sc.wait(None).await?;
                 dbg!(wait_response);
             }
 
-            // let read_result = sc.read(None)?;
+            // let read_result = sc.read(None).await?;
             // dbg!(read_result);
 
-            // let derive_result = card.derive()?;
+            // let derive_result = sc.derive().await?;
             // dbg!(&derive_result);
 
-            dbg!(sc.check_certificate().unwrap().name());
+            dbg!(sc.check_certificate().await.unwrap().name());
 
             // let nfc_result = card.nfc()?;
             // dbg!(nfc_result);
@@ -99,20 +100,20 @@ fn main() -> Result<(), Error> {
             //     if slot == &0 {
             //         // TODO must unseal first
             //         let chain_code = rand_chaincode(rng).to_vec();
-            //         let new_result = card.new_slot(0, chain_code, get_cvc())?;
+            //         let new_result = sc.new_slot(0, chain_code, get_cvc()).await?;
             //     }
             // }
 
             // let certs_result = card.certs()?;
             // dbg!(certs_result);
 
-            // let unseal_result = card.unseal(0, get_cvc())?;
+            // let unseal_result = sc.unseal(0, get_cvc()).await?;
             // dbg!(unseal_result);
 
-            // let dump_result = card.dump(0, None)?;
+            // let dump_result = sc.dump(0, None).await?;
             // dbg!(dump_result);
 
-            // let dump_result = card.dump(0, Some(get_cvc()))?;
+            // let dump_result = sc.dump(0, Some(get_cvc())).await?;
             // dbg!(dump_result);
         }
     }