extension: introduce TranslateExtParam trait

Right now the TranslateExt trait confusingly translates both Exts and
ExtParams. We will split this into two traits, and the ExtParam one
will work specifically with CovExt (other extensions will need to
implement their own traits).

Author: apoelstra

src/extensions/csfs.rs

@@ -10,6 +10,7 @@ use elements::hashes::hex;
 use elements::{self, opcodes, secp256k1_zkp};
 
 use super::{ArgFromStr, CovExtArgs, ExtParam, ParseableExt, TxEnv};
+use super::param::{ExtParamTranslator, TranslateExtParam};
 use crate::miniscript::context::ScriptContextError;
 use crate::miniscript::lex::{Token as Tk, TokenIter};
 use crate::miniscript::limits::MAX_STANDARD_P2WSH_STACK_ITEM_SIZE;
@@ -317,6 +318,26 @@ where
     }
 }
 
+impl<PArg, QArg> TranslateExtParam<PArg, QArg> for CheckSigFromStack<PArg>
+where
+    PArg: ExtParam,
+    QArg: ExtParam,
+{
+    type Output = CheckSigFromStack<QArg>;
+
+    fn translate_ext<T, E>(&self, t: &mut T) -> Result<Self::Output, E>
+    where
+        T: ExtParamTranslator<PArg, QArg, E>,
+        PArg: ExtParam,
+        QArg: ExtParam,
+    {
+        Ok(CheckSigFromStack {
+            pk: t.ext(&self.pk)?,
+            msg: t.ext(&self.msg)?,
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use bitcoin::XOnlyPublicKey;

src/extensions/introspect_ops.rs

@@ -12,6 +12,7 @@ use elements::opcodes::all::*;
 use elements::{confidential, encode, script, Address, AddressParams};
 
 use super::{ArgFromStr, CovExtArgs, EvalError, ExtParam, ParseableExt, TxEnv};
+use super::param::{ExtParamTranslator, TranslateExtParam};
 use crate::expression::{FromTree, Tree};
 use crate::miniscript::context::ScriptContextError;
 use crate::miniscript::lex::{Token as Tk, TokenIter};
@@ -1110,6 +1111,32 @@ where
     }
 }
 
+impl<PArg, QArg> TranslateExtParam<PArg, QArg> for CovOps<PArg>
+where
+    PArg: ExtParam,
+    QArg: ExtParam,
+{
+    type Output = CovOps<QArg>;
+
+    fn translate_ext<T, E>(&self, t: &mut T) -> Result<Self::Output, E>
+    where
+        T: ExtParamTranslator<PArg, QArg, E>,
+    {
+        match self {
+            CovOps::IsExpAsset(a) => Ok(CovOps::IsExpAsset(a._translate_ext(t)?)),
+            CovOps::IsExpValue(v) => Ok(CovOps::IsExpValue(v._translate_ext(t)?)),
+            CovOps::AssetEq(x, y) => {
+                Ok(CovOps::AssetEq(x._translate_ext(t)?, y._translate_ext(t)?))
+            }
+            CovOps::ValueEq(x, y) => {
+                Ok(CovOps::ValueEq(x._translate_ext(t)?, y._translate_ext(t)?))
+            }
+            CovOps::SpkEq(x, y) => Ok(CovOps::SpkEq(x._translate_ext(t)?, y._translate_ext(t)?)),
+            CovOps::CurrIndEq(i) => Ok(CovOps::CurrIndEq(*i)),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use bitcoin::XOnlyPublicKey;

src/extensions/param.rs

@@ -6,7 +6,7 @@ use bitcoin::hashes::hex::ToHex;
 use elements::confidential;
 use elements::encode::serialize;
 
-use crate::Error;
+use crate::{Error, ExtTranslator};
 use super::csfs::{CsfsKey, CsfsMsg};
 use super::introspect_ops::Spk;
 
@@ -176,3 +176,44 @@ impl ArgFromStr for CovExtArgs {
     }
 }
 
+/// Trait for translating different parameter types for covenant extensions
+pub trait ExtParamTranslator<PArg, QArg, E>
+where
+    PArg: ExtParam,
+    QArg: ExtParam,
+{
+    /// Translates one extension to another
+    fn ext(&mut self, e: &PArg) -> Result<QArg, E>;
+}
+
+// Use ExtParamTranslator as a ExTTranslator
+impl<T, PArg, QArg, E> ExtTranslator<PArg, QArg, E> for T
+where
+    T: ExtParamTranslator<PArg, QArg, E>,
+    PArg: ExtParam,
+    QArg: ExtParam,
+{
+    /// Translates one extension to another
+    fn ext(&mut self, e: &PArg) -> Result<QArg, E> {
+        ExtParamTranslator::ext(self, e)
+    }
+}
+
+
+/// Converts a descriptor using abstract extension parameters to one using concrete ones,
+/// or vice-versa
+pub trait TranslateExtParam<PArg, QArg>
+where
+    PArg: ExtParam,
+    QArg: ExtParam,
+{
+    /// The associated output type.
+    type Output;
+
+    /// Translates a struct from one generic to another where the translations
+    /// for Pk are provided by the given [`Translator`].
+    fn translate_ext<T, E>(&self, translator: &mut T) -> Result<Self::Output, E>
+    where
+        T: ExtParamTranslator<PArg, QArg, E>;
+}
+

src/test_utils.rs

@@ -6,8 +6,8 @@ use std::str::FromStr;
 use bitcoin::hashes::{hash160, sha256};
 use bitcoin::secp256k1;
 
-use crate::extensions::CovExtArgs;
-use crate::{ExtTranslator, MiniscriptKey, Translator};
+use crate::extensions::{param::ExtParamTranslator, CovExtArgs};
+use crate::{MiniscriptKey, Translator};
 
 /// Translate from a String MiniscriptKey type to bitcoin::PublicKey
 /// If the hashmap is populated, this will lookup for keys in HashMap
@@ -156,7 +156,7 @@ pub struct StrExtTransalator {
     pub ext_map: HashMap<String, CovExtArgs>,
 }
 
-impl ExtTranslator<String, CovExtArgs, ()> for StrExtTransalator {
+impl ExtParamTranslator<String, CovExtArgs, ()> for StrExtTransalator {
     fn ext(&mut self, e: &String) -> Result<CovExtArgs, ()> {
         let x = self.ext_map.get(e).expect("Ext Mapping not found");
         Ok(x.clone())