[MOVE ONLY] covenants: move ExtParams to its own module

Right now ExtParams and Ext are together in one module, and are confused
in places. My goal here is to isolate ExtParams within the extension module
as much as possible and have users mostly just deal with Ext.

Of course, to convert between CovenantExt<A> and CovenantExt<B> they will
need to deal with ExtParam, but we will expose that in a narrow sense
rather than having Descriptor<ExtParam> and a "TranslateExt" trait that
actually manipulates ExtParams.

Re-exports things in their own locations to minimize disruption to the
rest of the crate. At the end of this PR we will fix all the export paths.

Author: apoelstra

src/extensions/mod.rs

@@ -4,10 +4,8 @@
 
 use std::{fmt, hash};
 
-use bitcoin::hashes::hex::ToHex;
-use elements::encode::serialize;
 use elements::script::Builder;
-use elements::{confidential, Transaction, TxOut};
+use elements::{Transaction, TxOut};
 
 use crate::expression::Tree;
 use crate::interpreter::{self, Stack};
@@ -23,35 +21,17 @@ mod arith;
 mod csfs;
 mod introspect_ops;
 mod outputs_pref;
+pub mod param;
 mod tx_ver;
 
 pub use arith::{Arith, EvalError, Expr, ExprInner};
 pub use csfs::{CheckSigFromStack, CsfsKey, CsfsMsg};
-pub use introspect_ops::{AssetExpr, CovOps, SpkExpr, ValueExpr};
+pub use introspect_ops::{AssetExpr, CovOps, Spk, SpkExpr, ValueExpr};
 
-use self::introspect_ops::Spk;
 pub use self::outputs_pref::LegacyOutputsPref;
+pub use self::param::{ArgFromStr, CovExtArgs, ExtParam, NoExtParam};
 pub use self::tx_ver::LegacyVerEq;
 
-/// Trait for parsing extension arg from String
-/// Parse an argument from `s` given context of parent and argument position
-///
-/// When parsing all allowed parameters from string, we need to restrict where
-/// the parameters can be allowed. For example, csfs() should not have a txout
-/// parameter.
-///
-/// All parameters that should be parsed from extensions need to implement this
-pub trait ArgFromStr: Sized {
-    /// Parse an argument from `s` given context of parent and argument position
-    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error>;
-}
-/// Abstract parameter to Miniscript Extension
-pub trait ExtParam: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash + ArgFromStr {}
-
-impl<T> ExtParam for T where
-    T: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash + ArgFromStr
-{
-}
 
 /// Extensions to elements-miniscript.
 /// Refer to implementations(unimplemented!) for example and tutorials
@@ -138,24 +118,6 @@ pub trait ParseableExt:
         S: Satisfier<Pk>;
 }
 
-/// No Extensions for elements-miniscript
-/// All the implementations for the this function are unreachable
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
-pub enum NoExtParam {}
-
-impl fmt::Display for NoExtParam {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl ArgFromStr for NoExtParam {
-    fn arg_from_str(_s: &str, _parent: &str, _pos: usize) -> Result<Self, Error> {
-        // This will be removed in a followup commit
-        unreachable!("Called ArgFromStr for NoExt")
-    }
-}
-
 /// No Extensions for elements-miniscript
 /// All the implementations for the this function are unreachable
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
@@ -263,132 +225,6 @@ pub enum CovenantExt<T: ExtParam> {
     Introspect(CovOps<T>),
 }
 
-/// All known Extension parameters/arguments
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum CovExtArgs {
-    /// XOnlyPublicKey (in CSFS)
-    XOnlyKey(CsfsKey),
-    /// Message
-    CsfsMsg(CsfsMsg),
-    /// Asset
-    Asset(confidential::Asset),
-    /// Value
-    Value(confidential::Value),
-    /// Script
-    Script(Spk),
-}
-
-impl From<CsfsMsg> for CovExtArgs {
-    fn from(v: CsfsMsg) -> Self {
-        Self::CsfsMsg(v)
-    }
-}
-
-impl From<Spk> for CovExtArgs {
-    fn from(v: Spk) -> Self {
-        Self::Script(v)
-    }
-}
-
-impl From<confidential::Value> for CovExtArgs {
-    fn from(v: confidential::Value) -> Self {
-        Self::Value(v)
-    }
-}
-
-impl From<confidential::Asset> for CovExtArgs {
-    fn from(v: confidential::Asset) -> Self {
-        Self::Asset(v)
-    }
-}
-
-impl From<CsfsKey> for CovExtArgs {
-    fn from(v: CsfsKey) -> Self {
-        Self::XOnlyKey(v)
-    }
-}
-
-impl CovExtArgs {
-    /// Creates a new csfs key variant of [`CovExtArgs`]
-    pub fn csfs_key(key: bitcoin::XOnlyPublicKey) -> Self {
-        CovExtArgs::XOnlyKey(CsfsKey(key))
-    }
-
-    /// Creates a csfs message variant of [`CovExtArgs`]
-    pub fn csfs_msg(msg: elements::secp256k1_zkp::Message) -> Self {
-        CovExtArgs::CsfsMsg(CsfsMsg::new(msg.as_ref().to_vec()).expect("32 byte size message"))
-    }
-
-    /// Creates a new asset variant of [`CovExtArgs`]
-    pub fn asset(asset: confidential::Asset) -> Self {
-        Self::from(asset)
-    }
-
-    /// Creates a new value variant of [`CovExtArgs`]
-    pub fn value(value: confidential::Value) -> Self {
-        Self::from(value)
-    }
-
-    /// Creates a new script pubkey of [`CovExtArgs`]
-    pub fn spk(spk: elements::Script) -> Self {
-        Self::from(Spk(spk))
-    }
-}
-
-impl PartialOrd for CovExtArgs {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        // HACKY implementation, need Ord/PartialOrd to make it work with other components
-        // in the library
-        self.to_string().partial_cmp(&other.to_string())
-    }
-}
-
-impl Ord for CovExtArgs {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        // HACKY implementation, need Ord/PartialOrd to make it work with other components
-        // in the library
-        self.to_string().cmp(&other.to_string())
-    }
-}
-
-impl fmt::Display for CovExtArgs {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            CovExtArgs::XOnlyKey(x) => write!(f, "{}", x),
-            CovExtArgs::CsfsMsg(m) => write!(f, "{}", m),
-            CovExtArgs::Asset(a) => write!(f, "{}", serialize(a).to_hex()),
-            CovExtArgs::Value(v) => write!(f, "{}", serialize(v).to_hex()),
-            CovExtArgs::Script(s) => write!(f, "{}", s),
-        }
-    }
-}
-
-impl ArgFromStr for CovExtArgs {
-    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error> {
-        let arg = match (parent, pos) {
-            ("csfs", 0) => CovExtArgs::XOnlyKey(CsfsKey::arg_from_str(s, parent, pos)?),
-            ("csfs", 1) => CovExtArgs::CsfsMsg(CsfsMsg::arg_from_str(s, parent, pos)?),
-            ("asset_eq", 0) | ("asset_eq", 1) | ("is_exp_asset", 0) => {
-                CovExtArgs::Asset(confidential::Asset::arg_from_str(s, parent, pos)?)
-            }
-            ("value_eq", 0) | ("value_eq", 1) | ("is_exp_value", 0) => {
-                CovExtArgs::Value(confidential::Value::arg_from_str(s, parent, pos)?)
-            }
-            ("spk_eq", 0) | ("spk_eq", 1) => CovExtArgs::Script(Spk::arg_from_str(s, parent, pos)?),
-            _ => return Err(Error::Unexpected(s.to_string())),
-        };
-        Ok(arg)
-    }
-}
-
-impl ArgFromStr for String {
-    fn arg_from_str(s: &str, _parent: &str, _pos: usize) -> Result<Self, Error> {
-        // Abstract strings are parsed without context as they don't contain any concrete
-        // information
-        Ok(String::from(s))
-    }
-}
-
 // Apply the function on each arm
 macro_rules! all_arms_fn {
     ($slf: ident, $trt: ident, $f: ident, $($args:ident, )* ) => {

src/extensions/param.rs

@@ -0,0 +1,178 @@
+//! Parameters to certain covenants
+
+use std::{hash, fmt};
+
+use bitcoin::hashes::hex::ToHex;
+use elements::confidential;
+use elements::encode::serialize;
+
+use crate::Error;
+use super::csfs::{CsfsKey, CsfsMsg};
+use super::introspect_ops::Spk;
+
+/// Trait for parsing extension arg from String
+/// Parse an argument from `s` given context of parent and argument position
+///
+/// When parsing all allowed parameters from string, we need to restrict where
+/// the parameters can be allowed. For example, csfs() should not have a txout
+/// parameter.
+///
+/// All parameters that should be parsed from extensions need to implement this
+pub trait ArgFromStr: Sized {
+    /// Parse an argument from `s` given context of parent and argument position
+    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error>;
+}
+
+/// Abstract parameter to Miniscript Extension
+pub trait ExtParam: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash + ArgFromStr {}
+
+impl<T> ExtParam for T where
+    T: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash + ArgFromStr
+{
+}
+
+impl ArgFromStr for String {
+    fn arg_from_str(s: &str, _parent: &str, _pos: usize) -> Result<Self, Error> {
+        // Abstract strings are parsed without context as they don't contain any concrete
+        // information
+        Ok(String::from(s))
+    }
+}
+
+
+/// No Extensions for elements-miniscript
+/// All the implementations for the this function are unreachable
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
+pub enum NoExtParam {}
+
+impl fmt::Display for NoExtParam {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {}
+    }
+}
+
+impl ArgFromStr for NoExtParam {
+    fn arg_from_str(_s: &str, _parent: &str, _pos: usize) -> Result<Self, Error> {
+        // This will be removed in a followup commit
+        unreachable!("Called ArgFromStr for NoExt")
+    }
+}
+
+/// All known Extension parameters/arguments
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum CovExtArgs {
+    /// XOnlyPublicKey (in CSFS)
+    XOnlyKey(CsfsKey),
+    /// Message
+    CsfsMsg(CsfsMsg),
+    /// Asset
+    Asset(confidential::Asset),
+    /// Value
+    Value(confidential::Value),
+    /// Script
+    Script(Spk),
+}
+
+impl From<CsfsMsg> for CovExtArgs {
+    fn from(v: CsfsMsg) -> Self {
+        Self::CsfsMsg(v)
+    }
+}
+
+impl From<Spk> for CovExtArgs {
+    fn from(v: Spk) -> Self {
+        Self::Script(v)
+    }
+}
+
+impl From<confidential::Value> for CovExtArgs {
+    fn from(v: confidential::Value) -> Self {
+        Self::Value(v)
+    }
+}
+
+impl From<confidential::Asset> for CovExtArgs {
+    fn from(v: confidential::Asset) -> Self {
+        Self::Asset(v)
+    }
+}
+
+impl From<CsfsKey> for CovExtArgs {
+    fn from(v: CsfsKey) -> Self {
+        Self::XOnlyKey(v)
+    }
+}
+
+impl CovExtArgs {
+    /// Creates a new csfs key variant of [`CovExtArgs`]
+    pub fn csfs_key(key: bitcoin::XOnlyPublicKey) -> Self {
+        CovExtArgs::XOnlyKey(CsfsKey(key))
+    }
+
+    /// Creates a csfs message variant of [`CovExtArgs`]
+    pub fn csfs_msg(msg: elements::secp256k1_zkp::Message) -> Self {
+        CovExtArgs::CsfsMsg(CsfsMsg::new(msg.as_ref().to_vec()).expect("32 byte size message"))
+    }
+
+    /// Creates a new asset variant of [`CovExtArgs`]
+    pub fn asset(asset: confidential::Asset) -> Self {
+        Self::from(asset)
+    }
+
+    /// Creates a new value variant of [`CovExtArgs`]
+    pub fn value(value: confidential::Value) -> Self {
+        Self::from(value)
+    }
+
+    /// Creates a new script pubkey of [`CovExtArgs`]
+    pub fn spk(spk: elements::Script) -> Self {
+        Self::from(Spk(spk))
+    }
+}
+
+impl PartialOrd for CovExtArgs {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        // HACKY implementation, need Ord/PartialOrd to make it work with other components
+        // in the library
+        self.to_string().partial_cmp(&other.to_string())
+    }
+}
+
+impl Ord for CovExtArgs {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // HACKY implementation, need Ord/PartialOrd to make it work with other components
+        // in the library
+        self.to_string().cmp(&other.to_string())
+    }
+}
+
+impl fmt::Display for CovExtArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CovExtArgs::XOnlyKey(x) => write!(f, "{}", x),
+            CovExtArgs::CsfsMsg(m) => write!(f, "{}", m),
+            CovExtArgs::Asset(a) => write!(f, "{}", serialize(a).to_hex()),
+            CovExtArgs::Value(v) => write!(f, "{}", serialize(v).to_hex()),
+            CovExtArgs::Script(s) => write!(f, "{}", s),
+        }
+    }
+}
+
+impl ArgFromStr for CovExtArgs {
+    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error> {
+        let arg = match (parent, pos) {
+            ("csfs", 0) => CovExtArgs::XOnlyKey(CsfsKey::arg_from_str(s, parent, pos)?),
+            ("csfs", 1) => CovExtArgs::CsfsMsg(CsfsMsg::arg_from_str(s, parent, pos)?),
+            ("asset_eq", 0) | ("asset_eq", 1) | ("is_exp_asset", 0) => {
+                CovExtArgs::Asset(confidential::Asset::arg_from_str(s, parent, pos)?)
+            }
+            ("value_eq", 0) | ("value_eq", 1) | ("is_exp_value", 0) => {
+                CovExtArgs::Value(confidential::Value::arg_from_str(s, parent, pos)?)
+            }
+            ("spk_eq", 0) | ("spk_eq", 1) => CovExtArgs::Script(Spk::arg_from_str(s, parent, pos)?),
+            _ => return Err(Error::Unexpected(s.to_string())),
+        };
+        Ok(arg)
+    }
+}
+