Merge pull request #31 from varovainen/va-2025-01-30-fix-derivations

fix: numerical derivations

Author: Slesarew

Cargo.toml

@@ -32,7 +32,7 @@ zeroize = {version = "1.7.0", features = ["derive"]}
 [dev-dependencies]
 hex = "0.4.3"
 mnemonic-external = "0.1.0"
-sp-core = "34.0.0"
+sp-core = "35.0.0"
 
 [features]
 default = ["ed25519", "ecdsa", "sr25519", "std"]

src/common.rs

@@ -140,10 +140,23 @@ pub fn cut_path(path_and_pwd: &str) -> Option<FullDerivation<'_>> {
                         .captures_iter(path.as_str())
                         .map(|caps| {
                             let derivation = caps.name("derivation").expect("");
-                            if derivation.as_str().starts_with('/') {
-                                DeriveJunction::hard(&derivation.as_str()[1..])
+                            let (is_hard, derivation_body) = {
+                                if derivation.as_str().starts_with('/') {
+                                    (true, &derivation.as_str()[1..])
+                                } else {
+                                    (false, derivation.as_str())
+                                }
+                            };
+                            if let Ok(number) = str::parse::<u64>(derivation_body) {
+                                if is_hard {
+                                    DeriveJunction::hard(number)
+                                } else {
+                                    DeriveJunction::soft(number)
+                                }
+                            } else if is_hard {
+                                DeriveJunction::hard(derivation_body)
                             } else {
-                                DeriveJunction::soft(derivation.as_str())
+                                DeriveJunction::soft(derivation_body)
                             }
                         })
                         .collect()

src/ecdsa.rs

@@ -124,11 +124,7 @@ mod tests {
     use crate::common::{cut_path, ALICE_WORDS};
     use crate::ecdsa::{Pair as EcdsaPair, Public as EcdsaPublic, Signature as EcdsaSignature};
 
-    #[test]
-    fn identical_ecdsa() {
-        let derivation = "//hard//alicealicealicealicealicealicealicealice";
-        let password = "trickytrick";
-
+    fn identical_ecdsa(derivation: &str, password: &str) {
         // phrase and full derivation, for `sp-core` procedure
         let phrase_with_derivations = format!("{ALICE_WORDS}{derivation}");
 
@@ -178,4 +174,17 @@ mod tests {
         let public_import = EcdsaPublic(public_from_core);
         assert!(public_import.verify(msg, &signature_import));
     }
+
+    #[test]
+    fn test_identical_ecdsa_1() {
+        identical_ecdsa(
+            "//hard//alicealicealicealicealicealicealicealice",
+            "trickytrick",
+        )
+    }
+
+    #[test]
+    fn test_identical_ecdsa_2() {
+        identical_ecdsa("//1", "pwd")
+    }
 }

src/ed25519.rs

@@ -93,11 +93,7 @@ mod tests {
         Pair as Ed25519Pair, Public as Ed25519Public, Signature as Ed25519Signature,
     };
 
-    #[test]
-    fn identical_ed25519() {
-        let derivation = "//hard//alicealicealicealicealicealicealicealice";
-        let password = "trickytrick";
-
+    fn identical_ed25519(derivation: &str, password: &str) {
         // phrase and full derivation, for `sp-core` procedure
         let phrase_with_derivations = format!("{ALICE_WORDS}{derivation}");
 
@@ -148,4 +144,17 @@ mod tests {
         let public_import = Ed25519Public(public_from_core);
         assert!(public_import.verify(msg, &signature_import));
     }
+
+    #[test]
+    fn test_identical_ed25519_1() {
+        identical_ed25519(
+            "//hard//alicealicealicealicealicealicealicealice",
+            "trickytrick",
+        )
+    }
+
+    #[test]
+    fn test_identical_ed25519_2() {
+        identical_ed25519("//1", "pwd")
+    }
 }

src/sr25519.rs

@@ -147,11 +147,7 @@ mod tests {
         Pair as Sr25529Pair, Public as Sr25519Public, Signature as Sr25519Signature,
     };
 
-    #[test]
-    fn identical_sr25519() {
-        let derivation = "//hard/soft//alicealicealicealicealicealicealicealice";
-        let password = "trickytrick";
-
+    fn identical_sr25519(derivation: &str, password: &str) {
         // phrase and full derivation, for `sp-core` procedure
         let phrase_with_derivations = format!("{ALICE_WORDS}{derivation}");
 
@@ -223,11 +219,7 @@ mod tests {
 
     impl CryptoRng for DummyRng {}
 
-    #[test]
-    fn identical_sr25519_external_rng() {
-        let derivation = "//hard/soft//alicealicealicealicealicealicealicealice";
-        let password = "trickytrick";
-
+    fn identical_sr25519_external_rng(derivation: &str, password: &str) {
         // phrase and full derivation, for `sp-core` procedure
         let phrase_with_derivations = format!("{ALICE_WORDS}{derivation}");
 
@@ -276,4 +268,30 @@ mod tests {
             &public_import_into_core
         ));
     }
+
+    #[test]
+    fn test_identical_sr25519_1() {
+        identical_sr25519(
+            "//hard/soft//alicealicealicealicealicealicealicealice",
+            "trickytrick",
+        )
+    }
+
+    #[test]
+    fn test_identical_sr25519_2() {
+        identical_sr25519("//1", "pwd")
+    }
+
+    #[test]
+    fn test_identical_sr25519_1_external() {
+        identical_sr25519_external_rng(
+            "//hard/soft//alicealicealicealicealicealicealicealice",
+            "trickytrick",
+        )
+    }
+
+    #[test]
+    fn test_identical_sr25519_2_external() {
+        identical_sr25519_external_rng("//1", "pwd")
+    }
 }