feat: support uncompressed transparent private keys (5XXX)

Author: hhanh00

Cargo.lock

@@ -12,14 +12,25 @@ orchard = {git = "https://github.com/hhanh00/orchard.git", rev = "714e2e8feaf708
 
 zcash_note_encryption = {git = "https://github.com/zcash/zcash_note_encryption.git", rev = "ede44ea608e667c78309c598fbf4d70f69c15c29"}
 
-pczt = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-reddsa = {git = "https://github.com/ZcashFoundation/reddsa.git", rev = "975f9ca835c4b9196c81608e55192b0f711e951d"}
 sapling-crypto = {git = "https://github.com/hhanh00/sapling-crypto.git", rev = "50f15ecc5c292a7738e3c43d6879601bd7d241c8"}
-zcash_address = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_encoding = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_keys = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_primitives = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_proofs = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_protocol = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zcash_transparent = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
-zip321 = {git = "https://github.com/hhanh00/librustzcash.git", rev = "9a7f84682f97b1ba5fdd5eead84a66c818cb500e"}
+reddsa = {git = "https://github.com/ZcashFoundation/reddsa.git", rev = "975f9ca835c4b9196c81608e55192b0f711e951d"}
+
+pczt = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_address = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_encoding = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_keys = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_primitives = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_proofs = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_protocol = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zcash_transparent = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+zip321 = {git = "https://github.com/hhanh00/librustzcash.git", rev = "883d2883a319b7e9d0eae206e15626c90f317e28"}
+
+#pczt = {path = "../librustzcash/pczt"}
+#zcash_address = {path = "../librustzcash/components/zcash_address"}
+#zcash_encoding = {path = "../librustzcash/components/zcash_encoding"}
+#zcash_keys = {path = "../librustzcash/zcash_keys"}
+#zcash_primitives = {path = "../librustzcash/zcash_primitives"}
+#zcash_proofs = {path = "../librustzcash/zcash_proofs"}
+#zcash_protocol = {path = "../librustzcash/components/zcash_protocol"}
+#zcash_transparent = {path = "../librustzcash/zcash_transparent"}
+#zip321 = {path = "../librustzcash/components/zip321"}

Cargo.toml

@@ -143,6 +143,7 @@ pub async fn new_account(
                 None,
                 &pk,
                 &taddr.encode(network),
+                false,
             )
             .await?;
         }
@@ -180,7 +181,7 @@ pub async fn new_account(
             store_account_transparent_vk(&mut db_tx, account, tvk).await?;
             for di in &[0, dindex] {
                 let sk = derive_transparent_sk(tsk, 0, *di)?;
-                let (pk, taddr) = derive_transparent_address(tvk, 0, *di)?;
+                let (pk, taddr) = derive_transparent_address(tvk, 0, *di, false)?;
                 store_account_transparent_addr(
                     &mut db_tx,
                     account,
@@ -189,6 +190,7 @@ pub async fn new_account(
                     Some(sk),
                     &pk,
                     &taddr.encode(&network),
+                    false,
                 )
                 .await?;
                 // do not create two taddrs if dindex == 0
@@ -224,7 +226,7 @@ pub async fn new_account(
             let xvk = xsk.to_account_pubkey();
             store_account_transparent_vk(&mut db_tx, account, &xvk).await?;
             let sk = derive_transparent_sk(&xsk, 0, 0)?;
-            let (pk, address) = derive_transparent_address(&xvk, 0, 0)?;
+            let (pk, address) = derive_transparent_address(&xvk, 0, 0, false)?;
             store_account_transparent_addr(
                 &mut db_tx,
                 account,
@@ -233,6 +235,7 @@ pub async fn new_account(
                 Some(sk),
                 &pk,
                 &address.encode(&network),
+                false,
             )
             .await?;
         } else if let Ok(xvk) = ExtendedPublicKey::<PublicKey>::from_str(&key) {
@@ -241,7 +244,7 @@ pub async fn new_account(
             buf.extend_from_slice(&xvk.to_bytes());
             let xvk = AccountPubKey::deserialize(&buf.try_into().unwrap()).unwrap();
             store_account_transparent_vk(&mut db_tx, account, &xvk).await?;
-            let (pk, address) = derive_transparent_address(&xvk, 0, 0)?;
+            let (pk, address) = derive_transparent_address(&xvk, 0, 0, false)?;
             store_account_transparent_addr(
                 &mut db_tx,
                 account,
@@ -250,25 +253,45 @@ pub async fn new_account(
                 None,
                 &pk,
                 &address.encode(&network),
+                false,
             )
             .await?;
         } else if let Ok(sk) = bip38::import_tsk(&key) {
             let secp = secp256k1::Secp256k1::new();
-            let pk = sk.public_key(&secp);
-            let tpk = pk.serialize().to_vec();
+            let pk = sk.0.public_key(&secp);
+            let tpk = if sk.1 {
+                pk.serialize_uncompressed().to_vec()
+            } else {
+                pk.serialize().to_vec()
+            };
             let pkh: [u8; 20] = Ripemd160::digest(Sha256::digest(&tpk)).into();
             let addr = TransparentAddress::PublicKeyHash(pkh);
+            let address_str = addr.encode(&network);
             store_account_transparent_addr(
                 &mut db_tx,
                 account,
                 0,
                 0,
-                Some(sk.to_bytes().to_vec()),
+                Some(sk.0.to_bytes().to_vec()),
+                &tpk,
+                &address_str,
+                sk.1,
+            )
+            .await?;
+        } else if let Ok((_hrp, tpk)) = bech32::decode(&key) {
+            let pkh: [u8; 20] = Ripemd160::digest(Sha256::digest(&tpk)).into();
+            let addr = TransparentAddress::PublicKeyHash(pkh);
+            store_account_transparent_addr(
+                &mut db_tx,
+                account,
+                0,
+                0,
+                None,
                 &tpk,
                 &addr.encode(&network),
+                false,
             )
             .await?;
-        } else if let Ok((_, tpk)) = bech32::decode(&key) {
             let pkh: [u8; 20] = Ripemd160::digest(Sha256::digest(&tpk)).into();
             let addr = TransparentAddress::PublicKeyHash(pkh);
             store_account_transparent_addr(
@@ -279,6 +302,7 @@ pub async fn new_account(
                 None,
                 &tpk,
                 &addr.encode(&network),
+                false,
             )
             .await?;
         }
@@ -323,7 +347,7 @@ pub async fn new_account(
             Some(tvk) if pools & 1 != 0 => {
                 init_account_transparent(&mut db_tx, account, birth).await?;
                 store_account_transparent_vk(&mut db_tx, account, tvk).await?;
-                let (pk, address) = derive_transparent_address(tvk, 0, dindex)?;
+                let (pk, address) = derive_transparent_address(tvk, 0, dindex, false)?;
                 store_account_transparent_addr(
                     &mut db_tx,
                     account,
@@ -332,6 +356,7 @@ pub async fn new_account(
                     None,
                     &pk,
                     &address.encode(&network),
+                    false,
                 )
                 .await?;
             }
@@ -355,6 +380,9 @@ pub async fn new_account(
         }
         update_dindex(&mut db_tx, account, dindex, true).await?;
     }
+    else {
+        anyhow::bail!("Unsupported key");
+    }
     db_tx.commit().await?;
     Ok(account)
 }
@@ -376,15 +404,20 @@ pub fn derive_transparent_address(
     tvk: &AccountPubKey,
     scope: u32,
     dindex: u32,
+    uncompressed: bool,
 ) -> Result<(Vec<u8>, TransparentAddress)> {
     let sindex = TransparentKeyScope::custom(scope).unwrap();
-    let tpk = tvk
+    let pk = tvk
         .derive_address_pubkey(sindex, NonHardenedChildIndex::from_index(dindex).unwrap())
-        .unwrap()
-        .serialize();
-    let pkh: [u8; 20] = Ripemd160::digest(Sha256::digest(tpk)).into();
+        .unwrap();
+    let tpk = if uncompressed {
+        pk.serialize_uncompressed().to_vec()
+    } else {
+        pk.serialize().to_vec()
+    };
+    let pkh: [u8; 20] = Ripemd160::digest(Sha256::digest(&tpk)).into();
     let addr = TransparentAddress::PublicKeyHash(pkh);
-    Ok((tpk.to_vec(), addr))
+    Ok((tpk, addr))
 }
 
 pub async fn get_account_seed(
@@ -737,7 +770,7 @@ pub async fn generate_next_dindex(
                 .xsk
                 .as_ref()
                 .map(|tsk| derive_transparent_sk(tsk, 0, dindex).unwrap());
-            let (pk, address) = derive_transparent_address(&xvk, 0, dindex)?;
+            let (pk, address) = derive_transparent_address(&xvk, 0, dindex, false)?;
             (sk, pk, Some(address))
         }
         None if hw != 0 => {
@@ -758,6 +791,7 @@ pub async fn generate_next_dindex(
             sk,
             &pk,
             &address.encode(network),
+            false,
         )
         .await?;
     }
@@ -790,7 +824,7 @@ pub async fn generate_next_change_address(
         let sk = xsk
             .as_ref()
             .map(|tsk| derive_transparent_sk(tsk, 1, dindex).unwrap());
-        let (change_pk, change_address) = derive_transparent_address(tvk, 1, dindex)?;
+        let (change_pk, change_address) = derive_transparent_address(tvk, 1, dindex, false)?;
         let change_address = change_address.encode(network);
 
         store_account_transparent_addr(
@@ -801,6 +835,7 @@ pub async fn generate_next_change_address(
             sk,
             &change_pk,
             &change_address,
+            false,
         )
         .await?;
 
@@ -848,7 +883,7 @@ pub async fn get_addresses(
     let taddr = tkeys
         .xvk
         .as_ref()
-        .map(|xvk| derive_transparent_address(xvk, 0, dindex).unwrap().1);
+        .map(|xvk| derive_transparent_address(xvk, 0, dindex, false).unwrap().1);
 
     let dindex = dindex as u64;
     let saddr = skeys.address;

rust/src/account.rs

@@ -1,17 +1,23 @@
 use anyhow::Result;
 use secp256k1::SecretKey;
 
-pub fn export_tsk(sk: &SecretKey) -> String {
-    let mut v = sk.secret_bytes().to_vec();
-    v.push(0x01);
+pub struct TSecretKey(pub SecretKey, pub bool);
+
+pub fn export_tsk(sk: &TSecretKey) -> String {
+    let mut v = sk.0.secret_bytes().to_vec();
+    if !sk.1 {
+        v.push(0x01);
+    }
     bs58::encode(v).with_check_version(0x80).into_string()
 }
 
-pub fn import_tsk(tsk: &str) -> Result<SecretKey> {
+pub fn import_tsk(tsk: &str) -> Result<TSecretKey> {
     let v = bs58::decode(tsk).with_check(Some(0x80)).into_vec()?;
-    if v.len() != 34 {
-        return Err(anyhow::anyhow!("Invalid TSK length"));
+    tracing::info!("{}", hex::encode(&v));
+    if v.len() != 33 && v.len() != 34 {
+        return Err(anyhow::anyhow!("Invalid TSK length {}", v.len()));
     }
     let sk = SecretKey::from_slice(&v[1..33]).unwrap();
-    Ok(sk)
+    let compressed = v.len() == 34 && v[33] == 0x01;
+    Ok(TSecretKey(sk, !compressed))
 }