derive: add XprivAccount::derive method

derive/src/path.rs

@@ -64,7 +64,7 @@ impl<I: IdxBase> From<[I; 4]> for DerivationSeg<I> {
 impl<I: IdxBase> DerivationSeg<I> {
     pub fn new(index: I) -> Self { DerivationSeg(NonEmptyOrdSet::with(index)) }
 
-    pub fn with(iter: impl IntoIterator<Item = I>) -> Result<Self, confinement::Error> {
+    pub fn with(iter: impl IntoIterator<Item=I>) -> Result<Self, confinement::Error> {
         Confined::try_from_iter(iter).map(DerivationSeg)
     }
 
@@ -197,7 +197,8 @@ impl<I: Display> Display for DerivationPath<I> {
 }
 
 impl<I: FromStr> FromStr for DerivationPath<I>
-where IndexParseError: From<<I as FromStr>::Err>
+where
+    IndexParseError: From<<I as FromStr>::Err>,
 {
     type Err = DerivationParseError;
 
@@ -232,13 +233,15 @@ impl<'path, I: Copy> IntoIterator for &'path DerivationPath<I> {
 }
 
 impl<I> FromIterator<I> for DerivationPath<I> {
-    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self { Self(iter.into_iter().collect()) }
+    fn from_iter<T: IntoIterator<Item=I>>(iter: T) -> Self { Self(iter.into_iter().collect()) }
 }
 
 impl<I: Idx> DerivationPath<I> {
     /// Constructs empty derivation path.
     pub fn new() -> Self { Self(vec![]) }
 
+    pub fn with_capacity(capacity: usize) -> Self { Self(Vec::with_capacity(capacity)) }
+
     pub fn terminal(&self) -> Option<Terminal> {
         let mut iter = self.iter().rev();
         let index = iter.next()?;

derive/src/xkey.rs

@@ -839,6 +839,22 @@ impl XprivAccount {
 
     #[inline]
     pub fn to_derivation(&self) -> DerivationPath { self.origin.to_derivation() }
+
+    #[must_use]
+    pub fn derive(&self, path: impl AsRef<[HardenedIndex]>) -> Self {
+        let path = path.as_ref();
+        let xpriv = self.xpriv.derive_priv(path);
+        let mut prev = DerivationPath::with_capacity(self.origin.derivation.len() + path.len());
+        prev.extend(&self.origin.derivation);
+        prev.extend(path);
+        XprivAccount {
+            origin: XkeyOrigin {
+                master_fp: self.origin.master_fp,
+                derivation: prev,
+            },
+            xpriv,
+        }
+    }
 }
 
 impl Display for XprivAccount {
@@ -911,7 +927,7 @@ impl XpubDerivable {
     pub fn try_custom(
         xpub: Xpub,
         origin: XkeyOrigin,
-        keychains: impl IntoIterator<Item = Keychain>,
+        keychains: impl IntoIterator<Item=Keychain>,
     ) -> Result<Self, XkeyAccountError> {
         Ok(XpubDerivable {
             spec: XpubAccount::new(xpub, origin)?,
@@ -979,7 +995,9 @@ mod _serde {
 
     impl Serialize for Xpub {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: Serializer {
+        where
+            S: Serializer,
+        {
             if serializer.is_human_readable() {
                 serializer.serialize_str(&self.to_string())
             } else {
@@ -990,7 +1008,9 @@ mod _serde {
 
     impl<'de> Deserialize<'de> for Xpub {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: Deserializer<'de> {
+        where
+            D: Deserializer<'de>,
+        {
             if deserializer.is_human_readable() {
                 let s = String::deserialize(deserializer)?;
                 Xpub::from_str(&s).map_err(|err| {
@@ -1006,14 +1026,18 @@ mod _serde {
 
     impl Serialize for XpubAccount {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: Serializer {
+        where
+            S: Serializer,
+        {
             serializer.serialize_str(&self.to_string())
         }
     }
 
     impl<'de> Deserialize<'de> for XpubAccount {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: Deserializer<'de> {
+        where
+            D: Deserializer<'de>,
+        {
             let s = String::deserialize(deserializer)?;
             XpubAccount::from_str(&s).map_err(|err| {
                 de::Error::custom(format!(
@@ -1025,14 +1049,18 @@ mod _serde {
 
     impl Serialize for XpubDerivable {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: Serializer {
+        where
+            S: Serializer,
+        {
             serializer.serialize_str(&self.to_string())
         }
     }
 
     impl<'de> Deserialize<'de> for XpubDerivable {
         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: Deserializer<'de> {
+        where
+            D: Deserializer<'de>,
+        {
             let s = String::deserialize(deserializer)?;
             XpubDerivable::from_str(&s).map_err(|err| {
                 de::Error::custom(format!("invalid xpub derivation string representation; {err}"))