devtools: Detect more key formats with zcash-inspect

devtools/Cargo.toml

@@ -19,11 +19,11 @@ sha2.workspace = true
 zcash_address.workspace = true
 zcash_client_backend ={ workspace = true, features = ["lightwalletd-tonic-transport"] }
 zcash_encoding.workspace = true
-zcash_keys.workspace = true
+zcash_keys = { workspace = true, features = ["unstable"] }
 zcash_note_encryption.workspace = true
 zcash_primitives = { workspace = true, features = ["transparent-inputs"] }
 zcash_proofs = { workspace = true, features = ["directories"] }
-zcash_protocol.workspace = true
+zcash_protocol = {workspace = true, features = ["local-consensus"] }
 
 # Transparent
 secp256k1.workspace = true

devtools/src/bin/inspect/keys.rs

@@ -1,23 +1,29 @@
 use std::convert::TryInto;
 use std::iter;
 
-use bech32::ToBase32;
+use bech32::{FromBase32, ToBase32};
 use secrecy::Zeroize;
 use zcash_address::{
     unified::{self, Encoding},
     ToAddress, ZcashAddress,
 };
+use zcash_keys::keys::{UnifiedAddressRequest, UnifiedFullViewingKey};
 use zcash_primitives::{
     legacy::{
         keys::{AccountPrivKey, IncomingViewingKey},
         TransparentAddress,
     },
     zip32,
 };
-use zcash_protocol::consensus::NetworkConstants;
+use zcash_protocol::{
+    consensus::{Network, NetworkConstants, NetworkType},
+    local_consensus::LocalNetwork,
+};
 
 use crate::Context;
 
+pub(crate) mod view;
+
 pub(crate) fn inspect_mnemonic(mnemonic: bip0039::Mnemonic, context: Option<Context>) {
     eprintln!("Mnemonic phrase");
     eprintln!(" - Language: English");
@@ -162,3 +168,81 @@
         "WARNING: This mnemonic phrase is now likely cached in your terminal's history buffer."
     );
 }
+
+pub(crate) fn inspect_sapling_extsk(
+    raw: Vec<bech32::u5>,
+    variant: bech32::Variant,
+    network: NetworkType,
+) {
+    match Vec::<u8>::from_base32(&raw)
+        .map_err(|_| ())
+        .and_then(|data| sapling::zip32::ExtendedSpendingKey::read(&data[..]).map_err(|_| ()))
+    {
+        Err(_) => {
+            eprintln!("Invalid encoding that claims to be a Sapling extended spending key");
+        }
+        Ok(extsk) => {
+            eprintln!("Sapling extended spending key");
+            match variant {
+                bech32::Variant::Bech32 => (),
+                bech32::Variant::Bech32m => eprintln!("⚠️  Incorrectly encoded with Bech32m"),
+            }
+
+            let default_addr_bytes = extsk.default_address().1.to_bytes();
+            eprintln!(
+                "- Default address: {}",
+                bech32::encode(
+                    network.hrp_sapling_payment_address(),
+                    default_addr_bytes.to_base32(),
+                    bech32::Variant::Bech32,
+                )
+                .unwrap(),
+            );
+
+            #[allow(deprecated)]
+            if let Ok(ufvk) = UnifiedFullViewingKey::from_sapling_extended_full_viewing_key(
+                extsk.to_extended_full_viewing_key(),
+            ) {
+                let encoded_ufvk = match network {
+                    NetworkType::Main => ufvk.encode(&Network::MainNetwork),
+                    NetworkType::Test => ufvk.encode(&Network::TestNetwork),
+                    NetworkType::Regtest => ufvk.encode(&LocalNetwork {
+                        overwinter: None,
+                        sapling: None,
+                        blossom: None,
+                        heartwood: None,
+                        canopy: None,
+                        nu5: None,
+                        nu6: None,
+                        #[cfg(zcash_unstable = "zfuture")]
+                        z_future: None,
+                    }),
+                };
+                eprintln!("- UFVK: {encoded_ufvk}");
+
+                let (default_ua, _) = ufvk
+                    .default_address(UnifiedAddressRequest::unsafe_new(false, true, false))
+                    .expect("should exist");
+                let encoded_ua = match network {
+                    NetworkType::Main => default_ua.encode(&Network::MainNetwork),
+                    NetworkType::Test => default_ua.encode(&Network::TestNetwork),
+                    NetworkType::Regtest => default_ua.encode(&LocalNetwork {
+                        overwinter: None,
+                        sapling: None,
+                        blossom: None,
+                        heartwood: None,
+                        canopy: None,
+                        nu5: None,
+                        nu6: None,
+                        #[cfg(zcash_unstable = "zfuture")]
+                        z_future: None,
+                    }),
+                };
+                eprintln!("  - Default address: {encoded_ua}");
+            }
+        }
+    }
+
+    eprintln!();
+    eprintln!("WARNING: This spending key is now likely cached in your terminal's history buffer.");
+}

devtools/src/bin/inspect/keys/view.rs

@@ -0,0 +1,163 @@
+use bech32::{FromBase32, ToBase32};
+use zcash_address::unified::{self, Container, Encoding};
+use zcash_keys::keys::{UnifiedAddressRequest, UnifiedFullViewingKey};
+use zcash_protocol::{
+    consensus::{Network, NetworkConstants, NetworkType},
+    local_consensus::LocalNetwork,
+};
+
+pub(crate) fn inspect_ufvk(ufvk: unified::Ufvk, network: NetworkType) {
+    eprintln!("Unified full viewing key");
+    eprintln!(
+        " - Network: {}",
+        match network {
+            NetworkType::Main => "main",
+            NetworkType::Test => "testnet",
+            NetworkType::Regtest => "regtest",
+        }
+    );
+    eprintln!(" - Items:");
+    for item in ufvk.items() {
+        match item {
+            unified::Fvk::Orchard(data) => {
+                eprintln!(
+                    "   - Orchard ({})",
+                    unified::Ufvk::try_from_items(vec![unified::Fvk::Orchard(data)])
+                        .unwrap()
+                        .encode(&network)
+                );
+            }
+            unified::Fvk::Sapling(data) => {
+                eprintln!(
+                    "   - Sapling ({})",
+                    bech32::encode(
+                        network.hrp_sapling_extended_full_viewing_key(),
+                        data.to_base32(),
+                        bech32::Variant::Bech32,
+                    )
+                    .unwrap(),
+                );
+            }
+            unified::Fvk::P2pkh(data) => {
+                eprintln!("   - Transparent P2PKH");
+                eprintln!("     - Payload: {}", hex::encode(data));
+            }
+            unified::Fvk::Unknown { typecode, data } => {
+                eprintln!("   - Unknown");
+                eprintln!("     - Typecode: {}", typecode);
+                eprintln!("     - Payload: {}", hex::encode(data));
+            }
+        }
+    }
+}
+
+pub(crate) fn inspect_uivk(uivk: unified::Uivk, network: NetworkType) {
+    eprintln!("Unified incoming viewing key");
+    eprintln!(
+        " - Network: {}",
+        match network {
+            NetworkType::Main => "main",
+            NetworkType::Test => "testnet",
+            NetworkType::Regtest => "regtest",
+        }
+    );
+    eprintln!(" - Items:");
+    for item in uivk.items() {
+        match item {
+            unified::Ivk::Orchard(data) => {
+                eprintln!(
+                    "   - Orchard ({})",
+                    unified::Uivk::try_from_items(vec![unified::Ivk::Orchard(data)])
+                        .unwrap()
+                        .encode(&network)
+                );
+            }
+            unified::Ivk::Sapling(data) => {
+                eprintln!("   - Sapling");
+                eprintln!("     - Payload: {}", hex::encode(data));
+            }
+            unified::Ivk::P2pkh(data) => {
+                eprintln!("   - Transparent P2PKH");
+                eprintln!("     - Payload: {}", hex::encode(data));
+            }
+            unified::Ivk::Unknown { typecode, data } => {
+                eprintln!("   - Unknown");
+                eprintln!("     - Typecode: {}", typecode);
+                eprintln!("     - Payload: {}", hex::encode(data));
+            }
+        }
+    }
+}
+
+pub(crate) fn inspect_sapling_extfvk(
+    raw: Vec<bech32::u5>,
+    variant: bech32::Variant,
+    network: NetworkType,
+) {
+    match Vec::<u8>::from_base32(&raw)
+        .map_err(|_| ())
+        .and_then(|data| sapling::zip32::ExtendedFullViewingKey::read(&data[..]).map_err(|_| ()))
+    {
+        Err(_) => {
+            eprintln!("Invalid encoding that claims to be a Sapling extended full viewing key");
+        }
+        Ok(extfvk) => {
+            eprintln!("Sapling extended full viewing key");
+            match variant {
+                bech32::Variant::Bech32 => (),
+                bech32::Variant::Bech32m => eprintln!("⚠️  Incorrectly encoded with Bech32m"),
+            }
+
+            let default_addr_bytes = extfvk.default_address().1.to_bytes();
+            eprintln!(
+                "- Default address: {}",
+                bech32::encode(
+                    network.hrp_sapling_payment_address(),
+                    default_addr_bytes.to_base32(),
+                    bech32::Variant::Bech32,
+                )
+                .unwrap(),
+            );
+
+            if let Ok(ufvk) = UnifiedFullViewingKey::from_sapling_extended_full_viewing_key(extfvk)
+            {
+                let encoded_ufvk = match network {
+                    NetworkType::Main => ufvk.encode(&Network::MainNetwork),
+                    NetworkType::Test => ufvk.encode(&Network::TestNetwork),
+                    NetworkType::Regtest => ufvk.encode(&LocalNetwork {
+                        overwinter: None,
+                        sapling: None,
+                        blossom: None,
+                        heartwood: None,
+                        canopy: None,
+                        nu5: None,
+                        nu6: None,
+                        #[cfg(zcash_unstable = "zfuture")]
+                        z_future: None,
+                    }),
+                };
+                eprintln!("- Equivalent UFVK: {encoded_ufvk}");
+
+                let (default_ua, _) = ufvk
+                    .default_address(UnifiedAddressRequest::unsafe_new(false, true, false))
+                    .expect("should exist");
+                let encoded_ua = match network {
+                    NetworkType::Main => default_ua.encode(&Network::MainNetwork),
+                    NetworkType::Test => default_ua.encode(&Network::TestNetwork),
+                    NetworkType::Regtest => default_ua.encode(&LocalNetwork {
+                        overwinter: None,
+                        sapling: None,
+                        blossom: None,
+                        heartwood: None,
+                        canopy: None,
+                        nu5: None,
+                        nu6: None,
+                        #[cfg(zcash_unstable = "zfuture")]
+                        z_future: None,
+                    }),
+                };
+                eprintln!("  - Default address: {encoded_ua}");
+            }
+        }
+    }
+}

devtools/src/bin/inspect/main.rs

@@ -7,12 +7,17 @@
 use lazy_static::lazy_static;
 use secrecy::Zeroize;
 use tokio::runtime::Runtime;
-use zcash_address::ZcashAddress;
+use zcash_address::{
+    unified::{self, Encoding},
+    ZcashAddress,
+};
 use zcash_primitives::{block::BlockHeader, consensus::BranchId, transaction::Transaction};
 use zcash_proofs::{default_params_folder, load_parameters, ZcashParameters};
+use zcash_protocol::consensus::NetworkType;
 
 mod context;
 use context::{Context, ZUint256};
+use zcash_protocol::constants;
 
 mod address;
 mod block;
@@ -72,6 +77,36 @@
         inspect_bytes(bytes, opts.context, opts.lookup);
     } else if let Ok(addr) = ZcashAddress::try_from_encoded(&opts.data) {
         address::inspect(addr);
+    } else if let Ok((network, uivk)) = unified::Uivk::decode(&opts.data) {
+        keys::view::inspect_uivk(uivk, network);
+    } else if let Ok((network, ufvk)) = unified::Ufvk::decode(&opts.data) {
+        keys::view::inspect_ufvk(ufvk, network);
+    } else if let Ok((hrp, data, variant)) = bech32::decode(&opts.data) {
+        match hrp.as_str() {
+            constants::mainnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY => {
+                keys::view::inspect_sapling_extfvk(data, variant, NetworkType::Main);
+            }
+            constants::testnet::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY => {
+                keys::view::inspect_sapling_extfvk(data, variant, NetworkType::Test);
+            }
+            constants::regtest::HRP_SAPLING_EXTENDED_FULL_VIEWING_KEY => {
+                keys::view::inspect_sapling_extfvk(data, variant, NetworkType::Regtest);
+            }
+            constants::mainnet::HRP_SAPLING_EXTENDED_SPENDING_KEY => {
+                keys::inspect_sapling_extsk(data, variant, NetworkType::Main);
+            }
+            constants::testnet::HRP_SAPLING_EXTENDED_SPENDING_KEY => {
+                keys::inspect_sapling_extsk(data, variant, NetworkType::Test);
+            }
+            constants::regtest::HRP_SAPLING_EXTENDED_SPENDING_KEY => {
+                keys::inspect_sapling_extsk(data, variant, NetworkType::Regtest);
+            }
+            _ => {
+                // 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.");