Add translate functions

Author: sanket1729

src/descriptor/bare.rs

@@ -30,7 +30,7 @@ use {BareCtx, Error, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
+    DescriptorTrait, PkTranslate,
 };
 
 /// Create a Bare Descriptor. That is descriptor that is
@@ -175,6 +175,27 @@ where
     }
 }
 
+impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Bare<P> {
+    type Output = Bare<Q>;
+
+    fn translate_pk<Fpk, Fpkh, E>(
+        &self,
+        mut translatefpk: Fpk,
+        mut translatefpkh: Fpkh,
+    ) -> Result<Self::Output, E>
+    where
+        Fpk: FnMut(&P) -> Result<Q, E>,
+        Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
+        Q: MiniscriptKey,
+    {
+        Ok(Bare::new(
+            self.ms
+                .translate_pk(&mut translatefpk, &mut translatefpkh)?,
+        )
+        .expect("Translation cannot fail inside Bare"))
+    }
+}
+
 /// A bare PkH descriptor at top level
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Pkh<Pk: MiniscriptKey> {
@@ -333,3 +354,20 @@ where
         self.script_pubkey(to_pk_ctx)
     }
 }
+
+impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Pkh<P> {
+    type Output = Pkh<Q>;
+
+    fn translate_pk<Fpk, Fpkh, E>(
+        &self,
+        mut translatefpk: Fpk,
+        _translatefpkh: Fpkh,
+    ) -> Result<Self::Output, E>
+    where
+        Fpk: FnMut(&P) -> Result<Q, E>,
+        Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
+        Q: MiniscriptKey,
+    {
+        Ok(Pkh::new(translatefpk(&self.pk)?))
+    }
+}

src/descriptor/segwitv0.rs

@@ -28,7 +28,7 @@ use {Error, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey};
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
+    DescriptorTrait, PkTranslate, SortedMultiVec,
 };
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
@@ -247,6 +247,31 @@ where
     }
 }
 
+impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Wsh<P> {
+    type Output = Wsh<Q>;
+
+    fn translate_pk<Fpk, Fpkh, E>(
+        &self,
+        mut translatefpk: Fpk,
+        mut translatefpkh: Fpkh,
+    ) -> Result<Self::Output, E>
+    where
+        Fpk: FnMut(&P) -> Result<Q, E>,
+        Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
+        Q: MiniscriptKey,
+    {
+        let inner = match self.inner {
+            WshInner::SortedMulti(ref smv) => {
+                WshInner::SortedMulti(smv.translate_pk(&mut translatefpk)?)
+            }
+            WshInner::Ms(ref ms) => {
+                WshInner::Ms(ms.translate_pk(&mut translatefpk, &mut translatefpkh)?)
+            }
+        };
+        Ok(Wsh { inner: inner })
+    }
+}
+
 /// A bare Wpkh descriptor at top level
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Wpkh<Pk: MiniscriptKey> {
@@ -414,3 +439,20 @@ where
         addr.script_pubkey()
     }
 }
+
+impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Wpkh<P> {
+    type Output = Wpkh<Q>;
+
+    fn translate_pk<Fpk, Fpkh, E>(
+        &self,
+        mut translatefpk: Fpk,
+        _translatefpkh: Fpkh,
+    ) -> Result<Self::Output, E>
+    where
+        Fpk: FnMut(&P) -> Result<Q, E>,
+        Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
+        Q: MiniscriptKey,
+    {
+        Ok(Wpkh::new(translatefpk(&self.pk)?).expect("Uncompressed keys in Wpkh"))
+    }
+}

src/descriptor/sh.rs

@@ -31,7 +31,7 @@ use {Error, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey}
 
 use super::{
     checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
+    DescriptorTrait, PkTranslate, SortedMultiVec, Wpkh, Wsh,
 };
 
 /// A Legacy p2sh Descriptor
@@ -336,3 +336,34 @@ where
         }
     }
 }
+
+impl<P: MiniscriptKey, Q: MiniscriptKey> PkTranslate<P, Q> for Sh<P> {
+    type Output = Sh<Q>;
+
+    fn translate_pk<Fpk, Fpkh, E>(
+        &self,
+        mut translatefpk: Fpk,
+        mut translatefpkh: Fpkh,
+    ) -> Result<Self::Output, E>
+    where
+        Fpk: FnMut(&P) -> Result<Q, E>,
+        Fpkh: FnMut(&P::Hash) -> Result<Q::Hash, E>,
+        Q: MiniscriptKey,
+    {
+        let inner = match self.inner {
+            ShInner::Wsh(ref wsh) => {
+                ShInner::Wsh(wsh.translate_pk(&mut translatefpk, &mut translatefpkh)?)
+            }
+            ShInner::Wpkh(ref wpkh) => {
+                ShInner::Wpkh(wpkh.translate_pk(&mut translatefpk, &mut translatefpkh)?)
+            }
+            ShInner::SortedMulti(ref smv) => {
+                ShInner::SortedMulti(smv.translate_pk(&mut translatefpk)?)
+            }
+            ShInner::Ms(ref ms) => {
+                ShInner::Ms(ms.translate_pk(&mut translatefpk, &mut translatefpkh)?)
+            }
+        };
+        Ok(Sh { inner: inner })
+    }
+}