Enable Passphrase for Restore Command

src/subcommand/preview.rs

@@ -61,7 +61,8 @@ impl Preview {
       thread::sleep(Duration::from_millis(50));
     }
 
-    super::wallet::create::run(options.clone())?;
+    super::wallet::Wallet::Create(super::wallet::create::Create { passphrase: None })
+      .run(options.clone())?;
 
     let rpc_client = options.bitcoin_rpc_client_for_wallet_command(false)?;
 

src/subcommand/wallet.rs

@@ -15,7 +15,7 @@ use {
 };
 
 pub mod balance;
-pub(crate) mod create;
+pub mod create;
 pub(crate) mod inscribe;
 pub mod inscriptions;
 pub mod outputs;
@@ -31,7 +31,7 @@ pub(crate) enum Wallet {
   #[clap(about = "Get wallet balance")]
   Balance,
   #[clap(about = "Create new wallet")]
-  Create,
+  Create(create::Create),
   #[clap(about = "Create inscription")]
   Inscribe(inscribe::Inscribe),
   #[clap(about = "List wallet inscriptions")]
@@ -54,7 +54,7 @@ impl Wallet {
   pub(crate) fn run(self, options: Options) -> Result {
     match self {
       Self::Balance => balance::run(options),
-      Self::Create => create::run(options),
+      Self::Create(create) => create.run(options),
       Self::Inscribe(inscribe) => inscribe.run(options),
       Self::Inscriptions => inscriptions::run(options),
       Self::Receive => receive::run(options),

src/subcommand/wallet/create.rs

@@ -3,17 +3,32 @@ use super::*;
 #[derive(Serialize)]
 struct Output {
   mnemonic: Mnemonic,
+  passphrase: Option<String>,
 }
 
-pub(crate) fn run(options: Options) -> Result {
-  let mut entropy = [0; 16];
-  rand::thread_rng().fill_bytes(&mut entropy);
+#[derive(Debug, Parser)]
+pub(crate) struct Create {
+  #[clap(long, default_value = "", help = "Use <PASSPHRASE> to derive wallet seed.")]
+  pub(crate) passphrase: String,
+}
+
+impl Create {
+  pub(crate) fn run(self, options: Options) -> Result {
+    let mut entropy = [0; 16];
+    rand::thread_rng().fill_bytes(&mut entropy);
 
-  let mnemonic = Mnemonic::from_entropy(&entropy)?;
+    let mnemonic = Mnemonic::from_entropy(&entropy)?;
 
-  initialize_wallet(&options, mnemonic.to_seed(""))?;
+    initialize_wallet(
+      &options,
+      mnemonic.to_seed(self.passphrase.clone().unwrap_or("".into())),
+    )?;
 
-  print_json(Output { mnemonic })?;
+    print_json(Output {
+      mnemonic,
+      passphrase: self.passphrase,
+    })?;
 
-  Ok(())
+    Ok(())
+  }
 }

src/subcommand/wallet/restore.rs

@@ -4,11 +4,16 @@ use super::*;
 pub(crate) struct Restore {
   #[clap(help = "Restore wallet from <MNEMONIC>")]
   mnemonic: Mnemonic,
+  #[clap(long, help = "Use <PASSPHRASE> when deriving wallet")]
+  pub(crate) passphrase: Option<String>,
 }
 
 impl Restore {
   pub(crate) fn run(self, options: Options) -> Result {
-    initialize_wallet(&options, self.mnemonic.to_seed(""))?;
+    initialize_wallet(
+      &options,
+      self.mnemonic.to_seed(self.passphrase.unwrap_or("".into())),
+    )?;
 
     Ok(())
   }

tests/wallet/restore.rs

@@ -20,3 +20,31 @@ fn restore_generates_same_descriptors() {
 
   assert_eq!(rpc_server.descriptors(), descriptors);
 }
+
+#[test]
+fn restore_generates_same_descriptors_with_passphrase() {
+  let passphrase = "unittest";
+  let (mnemonic, descriptors) = {
+    let rpc_server = test_bitcoincore_rpc::spawn();
+
+    let Create { mnemonic } = CommandBuilder::new(["wallet", "create", "--passphrase", passphrase])
+      .rpc_server(&rpc_server)
+      .output::<Create>();
+
+    (mnemonic, rpc_server.descriptors())
+  };
+
+  let rpc_server = test_bitcoincore_rpc::spawn();
+
+  CommandBuilder::new([
+    "wallet",
+    "restore",
+    "--passphrase",
+    passphrase,
+    &mnemonic.to_string(),
+  ])
+  .rpc_server(&rpc_server)
+  .run();
+
+  assert_eq!(rpc_server.descriptors(), descriptors);
+}