inspect: Add support for transparent secret key encoding

This enables us to obtain the pubkey encoding from a `zcashd` wallet
export, which is useful for testing `pczt create-manual`.

Author: str4d

Cargo.lock

@@ -61,6 +61,7 @@ rust_decimal = "1"
 bech32 = "0.11"
 bellman = "0.14"
 blake2b_simd = "1"
+bs58 = "0.5"
 ed25519-zebra = "4"
 equihash = "0.2"
 group = "0.13"

Cargo.toml

@@ -95,6 +95,19 @@ impl Command {
                     process::exit(2);
                 }
             }
+        } else if let Ok(decoded) = bs58::decode(&opts.data).with_check(None).into_vec() {
+            match decoded.as_slice() {
+                // `constants::mainnet::B58_TRANSPARENT_SECRET_KEY_PREFIX`
+                [0x80, data @ ..] => keys::inspect_transparent_sk(data, NetworkType::Main),
+                // `constants::testnet::B58_TRANSPARENT_SECRET_KEY_PREFIX`
+                // (also regtest but we can't distinguish the two)
+                [0xEF, data @ ..] => keys::inspect_transparent_sk(data, NetworkType::Test),
+                _ => {
+                    // Unknown data format.
+                    eprintln!("String does not match known Zcash data formats.");
+                    process::exit(2);
+                }
+            }
         } else {
             // Unknown data format.
             eprintln!("String does not match known Zcash data formats.");

src/commands/inspect.rs

@@ -12,9 +12,12 @@ use zcash_address::{
     unified::{self, Encoding},
     ToAddress, ZcashAddress,
 };
-use zcash_keys::keys::{UnifiedAddressRequest, UnifiedFullViewingKey};
+use zcash_keys::{
+    encoding::AddressCodec,
+    keys::{UnifiedAddressRequest, UnifiedFullViewingKey},
+};
 use zcash_protocol::{
-    consensus::{Network, NetworkConstants, NetworkType},
+    consensus::{self, Network, NetworkConstants, NetworkType},
     local_consensus::LocalNetwork,
 };
 
@@ -220,3 +223,46 @@ pub(crate) fn inspect_sapling_extsk(data: Vec<u8>, network: NetworkType) {
     eprintln!();
     eprintln!("WARNING: This spending key is now likely cached in your terminal's history buffer.");
 }
+
+pub(crate) fn inspect_transparent_sk(data: &[u8], network: NetworkType) {
+    let (data, compressed) = match data.split_last() {
+        Some((b, rest)) if *b == 1 => (rest, true),
+        _ => (data, false),
+    };
+
+    match secp256k1::SecretKey::from_slice(data) {
+        Err(_) => {
+            eprintln!("Invalid encoding that claims to be a transparent secret key");
+        }
+        Ok(sk) => {
+            eprintln!("Transparent secret key");
+
+            let pubkey = sk.public_key(&secp256k1::Secp256k1::signing_only());
+            eprintln!(
+                "- Public key: {}",
+                if compressed {
+                    hex::encode(pubkey.serialize())
+                } else {
+                    hex::encode(pubkey.serialize_uncompressed())
+                }
+            );
+
+            if compressed {
+                let params = match network {
+                    NetworkType::Main => consensus::Network::MainNetwork,
+                    NetworkType::Test => consensus::Network::TestNetwork,
+                    NetworkType::Regtest => unreachable!(),
+                };
+
+                // `TransparentAddress::from_pubkey` only supports compressed encodings.
+                eprintln!(
+                    "- P2PKH address: {}",
+                    TransparentAddress::from_pubkey(&pubkey).encode(&params),
+                );
+            }
+        }
+    }
+
+    eprintln!();
+    eprintln!("WARNING: This secret key is now likely cached in your terminal's history buffer.");
+}