-x importwallet

horologger · horologger · commit d60a1ad79d36 · 2025-09-05T10:40:53.000-04:00
diff --git a/client/src/bin/space-cli.rs b/client/src/bin/space-cli.rs
@@ -42,6 +42,7 @@ use spaces_wallet::{
     nostr::{NostrEvent, NostrTag},
     Listing,
 };
+use hex;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -107,6 +108,9 @@ enum Commands {
     ImportWallet {
         // Wallet json file to import
         path: PathBuf,
+        /// Use hex-encoded private key from json to generate taproot descriptor
+        #[arg(long, short = 'x')]
+        hex_secret: bool,
     },
     /// Export a wallet
     #[command(name = "getwalletinfo")]
@@ -539,6 +543,26 @@ fn normalize_space(space: &str) -> String {
     }
 }
 
+fn generate_taproot_descriptor_from_hex(hex_secret: &str, _network: ExtendedNetwork) -> Result<String, ClientError> {
+    // Parse hex secret
+    let secret_bytes = hex::decode(hex_secret)
+        .map_err(|e| ClientError::Custom(format!("Invalid hex secret: {}", e)))?;
+    
+    if secret_bytes.len() != 32 {
+        return Err(ClientError::Custom("Hex secret must be 32 bytes (64 hex characters)".to_string()));
+    }
+    
+    // For now, create a simple descriptor that indicates this is a hex-based import
+    // The actual xprv conversion would need to be done properly in the wallet creation
+    // This is a placeholder that will need to be handled by the wallet creation process
+    let descriptor = format!(
+        "tr([hex:{}]/86'/0'/0'/0/*)",
+        hex_secret
+    );
+    
+    Ok(descriptor)
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let (cli, args) = SpaceCli::configure().await?;
@@ -632,10 +656,28 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
         Commands::LoadWallet => {
             cli.client.wallet_load(&cli.wallet).await?;
         }
-        Commands::ImportWallet { path } => {
+        Commands::ImportWallet { path, hex_secret } => {
             let content =
                 fs::read_to_string(path).map_err(|e| ClientError::Custom(e.to_string()))?;
-            let wallet: WalletExport = serde_json::from_str(&content)?;
+            let mut wallet: WalletExport = serde_json::from_str(&content)?;
+            
+            // If hex_secret is requested, generate taproot descriptor from hex secret
+            if hex_secret {
+                if let Some(hex_secret_value) = &wallet.hex_secret {
+                    // For now, we'll create a simple descriptor format
+                    // The actual conversion to xprv should be done in the wallet creation process
+                    let taproot_descriptor = format!("tr([hex:{}]/86'/0'/0'/0/*)", hex_secret_value);
+                    wallet.descriptor = Some(taproot_descriptor);
+                } else {
+                    return Err(ClientError::Custom("hex-secret option specified but no hex_secret found in wallet json".to_string()));
+                }
+            } else {
+                // If not using hex_secret, ensure descriptor is present
+                if wallet.descriptor.is_none() {
+                    return Err(ClientError::Custom("descriptor field is required when not using hex-secret option".to_string()));
+                }
+            }
+            
             cli.client.wallet_import(wallet).await?;
         }
         Commands::ExportWallet { path, hex_secret } => {
diff --git a/client/src/rpc.rs b/client/src/rpc.rs
@@ -509,8 +509,10 @@ impl WalletManager {
         // If hex_secret is requested, we need to extract it from the wallet descriptor
         if hex_secret {
             // Parse the descriptor to extract the xprv and get the hex secret
-            if let Some(hex_secret_value) = self.extract_hex_secret_from_descriptor(&export.descriptor)? {
-                export.hex_secret = Some(hex_secret_value);
+            if let Some(descriptor) = &export.descriptor {
+                if let Some(hex_secret_value) = self.extract_hex_secret_from_descriptor(descriptor)? {
+                    export.hex_secret = Some(hex_secret_value);
+                }
             }
         }
         
@@ -650,11 +652,55 @@ impl WalletManager {
             name: name.to_string(),
             network,
             genesis_hash,
-            space_descriptors: WalletDescriptors {
-                external: export.descriptor(),
-                internal: export
-                    .change_descriptor()
-                    .expect("expected a change descriptor"),
+            space_descriptors: {
+                let external_descriptor = export.descriptor().expect("expected a descriptor");
+                let internal_descriptor = export.change_descriptor().expect("expected a change descriptor");
+                
+                // Check if this is a hex-based descriptor and convert it
+                let (external, internal) = if external_descriptor.starts_with("tr([hex:") {
+                    // Extract hex secret from descriptor
+                    if let Some(hex_secret) = export.hex_secret.as_ref() {
+                        // Convert hex secret to proper xprv and create descriptors
+                        let xpriv = Self::xpriv_from_hex_secret(network, hex_secret)?;
+                        let (external_desc, internal_desc) = Self::default_descriptors(xpriv);
+                        
+                        // Create a temporary wallet to get the descriptor strings
+                        let temp_wallet = bdk::Wallet::create(external_desc, internal_desc)
+                            .network(network)
+                            .create_wallet_no_persist()?;
+                        
+                        // Get descriptor strings using the same method as WalletExport
+                        let external_str = temp_wallet
+                            .public_descriptor(KeychainKind::External)
+                            .to_string_with_secret(
+                                &temp_wallet
+                                    .get_signers(KeychainKind::External)
+                                    .as_key_map(temp_wallet.secp_ctx()),
+                            );
+                        let internal_str = temp_wallet
+                            .public_descriptor(KeychainKind::Internal)
+                            .to_string_with_secret(
+                                &temp_wallet
+                                    .get_signers(KeychainKind::Internal)
+                                    .as_key_map(temp_wallet.secp_ctx()),
+                            );
+                        
+                        // Remove checksums (same as WalletExport does)
+                        let external_str = Self::remove_checksum(external_str);
+                        let internal_str = Self::remove_checksum(internal_str);
+                        
+                        (external_str, internal_str)
+                    } else {
+                        return Err(anyhow!("Hex-based descriptor found but no hex_secret in export"));
+                    }
+                } else {
+                    (external_descriptor, internal_descriptor)
+                };
+                
+                WalletDescriptors {
+                    external,
+                    internal,
+                }
             },
         };
 
@@ -692,13 +738,57 @@ impl WalletManager {
         Ok(xkey.into_xprv(network).expect("xpriv"))
     }
 
+    fn xpriv_from_hex_secret(network: Network, hex_secret: &str) -> anyhow::Result<Xpriv> {
+        use spaces_protocol::bitcoin::bip32::Xpriv;
+        use spaces_protocol::bitcoin::key::Secp256k1;
+        use spaces_protocol::bitcoin::secp256k1::SecretKey;
+        
+        // Parse hex secret
+        let secret_bytes = hex::decode(hex_secret)
+            .map_err(|e| anyhow!("Invalid hex secret: {}", e))?;
+        
+        if secret_bytes.len() != 32 {
+            return Err(anyhow!("Hex secret must be 32 bytes (64 hex characters)"));
+        }
+        
+        // Convert to SecretKey
+        let secret_key = SecretKey::from_slice(&secret_bytes)
+            .map_err(|e| anyhow!("Invalid secret key: {}", e))?;
+        
+        // Create Xpriv from secret key
+        let secp = Secp256k1::new();
+        let xpriv = Xpriv::new_master(network, &secret_key.secret_bytes())
+            .map_err(|e| anyhow!("Failed to create xpriv: {}", e))?;
+        
+        Ok(xpriv)
+    }
+
+    fn descriptor_from_hex_secret(network: Network, hex_secret: &str) -> anyhow::Result<String> {
+        // Parse hex secret
+        let secret_bytes = hex::decode(hex_secret)
+            .map_err(|e| anyhow!("Invalid hex secret: {}", e))?;
+        
+        if secret_bytes.len() != 32 {
+            return Err(anyhow!("Hex secret must be 32 bytes (64 hex characters)"));
+        }
+        
+        // For now, create a simple descriptor that can be processed by the wallet creation
+        // The actual xprv conversion will need to be handled in the wallet creation process
+        // This is a placeholder format that indicates this is a hex-based import
+        Ok(format!("tr([hex:{}]/86'/0'/0'/0/*)", hex_secret))
+    }
+
     fn default_descriptors(x: Xpriv) -> (Bip86<Xpriv>, Bip86<Xpriv>) {
         (
             Bip86(x, KeychainKind::External),
             Bip86(x, KeychainKind::Internal),
         )
     }
 
+    fn remove_checksum(s: String) -> String {
+        s.split_once('#').map(|(a, _)| String::from(a)).unwrap_or(s)
+    }
+
     fn extract_hex_secret_from_descriptor(&self, descriptor: &str) -> anyhow::Result<Option<String>> {
         // Parse the descriptor to extract the xprv
         // The descriptor format is typically: tr([xprv...]/path)...
@@ -722,6 +812,11 @@ impl WalletManager {
         
         Ok(None)
     }
+
+    pub fn create_taproot_descriptor_from_hex(&self, hex_secret: &str) -> anyhow::Result<String> {
+        let (network, _) = self.fallback_network();
+        Self::descriptor_from_hex_secret(network, hex_secret)
+    }
 }
 
 impl RpcServerImpl {
diff --git a/wallet/src/export.rs b/wallet/src/export.rs
@@ -21,7 +21,9 @@ use hex;
 /// For a usage example see [this module](crate::wallet::export)'s documentation.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct WalletExport {
-    pub descriptor: String,
+    /// Wallet descriptor (optional when using hex-secret import)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub descriptor: Option<String>,
     /// Earliest block to rescan when looking for the wallet's transactions
     pub blockheight: u32,
     /// Arbitrary label for the wallet
@@ -95,7 +97,7 @@ impl WalletExport {
         };
 
         let export = WalletExport {
-            descriptor,
+            descriptor: Some(descriptor),
             label: label.into(),
             blockheight,
             hex_secret,
@@ -120,16 +122,19 @@ impl WalletExport {
     }
 
     /// Return the external descriptor
-    pub fn descriptor(&self) -> String {
+    pub fn descriptor(&self) -> Option<String> {
         self.descriptor.clone()
     }
 
     /// Return the internal descriptor, if present
     pub fn change_descriptor(&self) -> Option<String> {
-        let replaced = self.descriptor.replace("/0/*", "/1/*");
-
-        if replaced != self.descriptor {
-            Some(replaced)
+        if let Some(descriptor) = &self.descriptor {
+            let replaced = descriptor.replace("/0/*", "/1/*");
+            if replaced != *descriptor {
+                Some(replaced)
+            } else {
+                None
+            }
         } else {
             None
         }
