test: Add test for derivation path

Author: ItoroD

bdk-ffi/src/bitcoin.rs

@@ -3,6 +3,8 @@ use crate::error::{
     PsbtParseError, TransactionError,
 };
 use crate::error::{ParseAmountError, PsbtFinalizeError};
+use crate::keys::DerivationPath;
+
 use crate::{impl_from_core_type, impl_hash_like, impl_into_core_type};
 use std::collections::HashMap;
 
@@ -523,7 +525,7 @@ pub struct KeySource {
     /// A fingerprint
     pub fingerprint: String,
     /// A BIP-32 derivation path.
-    pub path: String,
+    pub path: Arc<DerivationPath>,
 }
 
 #[derive(Clone, Debug, uniffi::Record, Hash, Eq, PartialEq)]
@@ -655,7 +657,7 @@ impl From<&BdkInput> for Input {
                         pk.to_string(),
                         KeySource {
                             fingerprint: fingerprint.to_string(),
-                            path: deriv_path.to_string(),
+                            path: Arc::new(deriv_path.clone().into()),
                         },
                     )
                 })
@@ -723,7 +725,7 @@ impl From<&BdkInput> for Input {
                         tap_leaf_hashes: v.0.iter().map(|h| h.to_string()).collect(),
                         key_source: KeySource {
                             fingerprint: v.1 .0.to_string(),
-                            path: v.1 .1.to_string(),
+                            path: Arc::new(v.1 .1.clone().into()),
                         },
                     };
                     (key, value)

bdk-ffi/src/keys.rs

@@ -1,18 +1,19 @@
 use crate::error::{Bip32Error, Bip39Error, DescriptorKeyError};
+use crate::{impl_from_core_type, impl_into_core_type};
 
-use bdk_wallet::bitcoin::Network;
 use bdk_wallet::bitcoin::bip32::DerivationPath as BdkDerivationPath;
 use bdk_wallet::bitcoin::key::Secp256k1;
 use bdk_wallet::bitcoin::secp256k1::rand;
 use bdk_wallet::bitcoin::secp256k1::rand::Rng;
+use bdk_wallet::bitcoin::Network;
 use bdk_wallet::keys::bip39::WordCount;
 use bdk_wallet::keys::bip39::{Language, Mnemonic as BdkMnemonic};
 use bdk_wallet::keys::{
     DerivableKey, DescriptorPublicKey as BdkDescriptorPublicKey,
     DescriptorSecretKey as BdkDescriptorSecretKey, ExtendedKey, GeneratableKey, GeneratedKey,
 };
-use bdk_wallet::miniscript::BareCtx;
 use bdk_wallet::miniscript::descriptor::{DescriptorXKey, Wildcard};
+use bdk_wallet::miniscript::BareCtx;
 
 use std::fmt::Display;
 use std::str::FromStr;
@@ -64,7 +65,7 @@ impl Display for Mnemonic {
 }
 
 /// A BIP-32 derivation path.
-#[derive(uniffi::Object)]
+#[derive(Clone, Debug, Hash, Eq, PartialEq, uniffi::Object)]
 pub struct DerivationPath(pub(crate) BdkDerivationPath);
 
 #[uniffi::export]
@@ -80,40 +81,34 @@ impl DerivationPath {
     /// Returns derivation path for a master key (i.e. empty derivation path)
     #[uniffi::constructor]
     pub fn master() -> Arc<Self> {
-        Arc::new(DerivationPath {
-            inner_mutex: Mutex::new(BdkDerivationPath::master()),
-        })
+        Arc::new(BdkDerivationPath::master().into())
     }
 
     /// Returns whether derivation path represents master key (i.e. it's length
     /// is empty). True for `m` path.
     pub fn is_master(&self) -> bool {
-        self.get_derivation_path().is_master()
+        self.0.is_master()
     }
 
     /// Returns length of the derivation path
     pub fn len(&self) -> u64 {
-        self.get_derivation_path().len() as u64
+        self.0.len() as u64
     }
 
     /// Returns `true` if the derivation path is empty
     pub fn is_empty(&self) -> bool {
-        self.get_derivation_path().is_empty()
+        self.0.is_empty()
     }
 }
 
 impl Display for DerivationPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let path = self.get_derivation_path();
-        write!(f, "{}", path)
+        write!(f, "{}", self.0)
     }
 }
 
-impl DerivationPath {
-    pub(crate) fn get_derivation_path(&self) -> MutexGuard<'_, BdkDerivationPath> {
-        self.inner_mutex.lock().expect("derivation path")
-    }
-}
+impl_from_core_type!(BdkDerivationPath, DerivationPath);
+impl_into_core_type!(DerivationPath, BdkDerivationPath);
 
 /// A descriptor containing secret data.
 #[derive(Debug, uniffi::Object)]

bdk-ffi/src/tests/bitcoin.rs

@@ -442,7 +442,7 @@ fn test_psbt_input_bip32_derivation() {
         "Fingerprint does not match the expected value"
     );
 
-    let derivation_path = &derivation.unwrap().path;
+    let derivation_path = &derivation.unwrap().path.to_string();
     let expected_derivation_path = "84'/1'/0'/0/0";
     assert_eq!(
         derivation_path, &expected_derivation_path,

bdk-ffi/src/tests/keys.rs

@@ -112,3 +112,28 @@ fn test_derive_hardened_path_using_public() {
     let derived_dpk = &derive_dpk(&master_dpk, "m/84h/1h/0h");
     assert!(derived_dpk.is_err());
 }
+
+#[test]
+fn test_derivation_path_parsing() {
+    let path_str = "m/44h/0h/0h/0/0";
+    let expected_path = "44'/0'/0'/0/0";
+    let path_str_2 = "m";
+
+    let derivation_path = DerivationPath::new(path_str.to_string()).unwrap();
+    assert_eq!(derivation_path.to_string(), expected_path);
+
+    let derivation_path2 = DerivationPath::new(path_str_2.to_string()).unwrap();
+    assert!(derivation_path2.is_master());
+
+    let derivation_path3 = DerivationPath::master();
+    assert!(derivation_path3.is_master());
+
+    assert!(!derivation_path.is_master());
+}
+
+#[test]
+fn test_invalid_derivation_path() {
+    let invalid_path_str = "m/44x/0h/0h/0/0";
+    let result = DerivationPath::new(invalid_path_str.to_string());
+    assert!(result.is_err());
+}