Replace Pk with KeyExpr<Pk>

src/descriptor/bare.rs

@@ -26,6 +26,7 @@ use bitcoin::{Address, Network, Script};
 use super::checksum::{desc_checksum, verify_checksum};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
+use crate::miniscript::musig_key::KeyExpr;
 use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::{varint_len, witness_to_scriptsig};
@@ -219,7 +220,7 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     /// sighash suffix. Includes the weight of the VarInts encoding the
     /// scriptSig and witness stack length.
     pub fn max_satisfaction_weight(&self) -> usize {
-        4 * (1 + 73 + BareCtx::pk_len(&self.pk))
+        4 * (1 + 73 + BareCtx::pk_len(&KeyExpr::SingleKey(self.pk.clone())))
     }
 }
 

src/descriptor/mod.rs

@@ -34,6 +34,7 @@ use bitcoin::{self, secp256k1, Address, Network, Script, TxIn};
 use sync::Arc;
 
 use self::checksum::verify_checksum;
+use crate::miniscript::musig_key::KeyExpr;
 use crate::miniscript::{Legacy, Miniscript, Segwitv0};
 use crate::prelude::*;
 use crate::{
@@ -180,7 +181,7 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
         // roundabout way to constuct `c:pk_k(pk)`
         let ms: Miniscript<Pk, BareCtx> =
             Miniscript::from_ast(miniscript::decode::Terminal::Check(Arc::new(
-                Miniscript::from_ast(miniscript::decode::Terminal::PkK(pk))
+                Miniscript::from_ast(miniscript::decode::Terminal::PkK(KeyExpr::SingleKey(pk)))
                     .expect("Type check cannot fail"),
             )))
             .expect("Type check cannot fail");

src/descriptor/segwitv0.rs

@@ -24,6 +24,7 @@ use super::checksum::{desc_checksum, verify_checksum};
 use super::SortedMultiVec;
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::{ScriptContext, ScriptContextError};
+use crate::miniscript::musig_key::KeyExpr;
 use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::varint_len;
@@ -330,7 +331,7 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
     /// sighash suffix. Includes the weight of the VarInts encoding the
     /// scriptSig and witness stack length.
     pub fn max_satisfaction_weight(&self) -> usize {
-        4 + 1 + 73 + Segwitv0::pk_len(&self.pk)
+        4 + 1 + 73 + Segwitv0::pk_len(&KeyExpr::SingleKey(self.pk.clone()))
     }
 }
 

src/descriptor/sortedmulti.rs

@@ -25,6 +25,7 @@ use bitcoin::blockdata::script;
 use crate::miniscript::context::ScriptContext;
 use crate::miniscript::decode::Terminal;
 use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
+use crate::miniscript::musig_key::KeyExpr;
 use crate::prelude::*;
 use crate::{
     errstr, expression, miniscript, policy, script_num_size, Error, ForEachKey, Miniscript,
@@ -183,7 +184,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         script_num_size(self.k)
             + 1
             + script_num_size(self.pks.len())
-            + self.pks.iter().map(|pk| Ctx::pk_len(pk)).sum::<usize>()
+            + self
+                .pks
+                .iter()
+                .map(|pk| Ctx::pk_len(&KeyExpr::SingleKey(pk.clone())))
+                .sum::<usize>()
     }
 
     /// Maximum number of witness elements used to satisfy the Miniscript

src/interpreter/mod.rs

@@ -593,7 +593,10 @@ where
                 Terminal::PkK(ref pk) => {
                     debug_assert_eq!(node_state.n_evaluated, 0);
                     debug_assert_eq!(node_state.n_satisfied, 0);
-                    let res = self.stack.evaluate_pk(&mut self.verify_sig, *pk);
+                    let res = match pk.single_key() {
+                        Some(pk) => self.stack.evaluate_pk(&mut self.verify_sig, *pk),
+                        None => None,
+                    };
                     if res.is_some() {
                         return res;
                     }
@@ -868,10 +871,11 @@ where
                         // evaluate each key with as a pk
                         // note that evaluate_pk will error on non-empty incorrect sigs
                         // push 1 on satisfied sigs and push 0 on empty sigs
-                        match self
-                            .stack
-                            .evaluate_pk(&mut self.verify_sig, subs[node_state.n_evaluated])
-                        {
+                        let temp = match subs[node_state.n_evaluated].single_key() {
+                            Some(pkk) => self.stack.evaluate_pk(&mut self.verify_sig, *pkk),
+                            None => None,
+                        };
+                        match temp {
                             Some(Ok(x)) => {
                                 self.push_evaluation_state(
                                     node_state.node,

src/miniscript/astelem.rs

@@ -26,6 +26,7 @@ use bitcoin::blockdata::{opcodes, script};
 use sync::Arc;
 
 use crate::miniscript::context::SigType;
+use crate::miniscript::musig_key::KeyExpr;
 use crate::miniscript::types::{self, Property};
 use crate::miniscript::ScriptContext;
 use crate::prelude::*;
@@ -80,7 +81,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
         Pk::RawPkHash: 'a,
     {
         match *self {
-            Terminal::PkK(ref p) => pred(p),
+            Terminal::PkK(ref p) => p.for_each_key(pred),
             Terminal::PkH(ref p) => pred(p),
             Terminal::RawPkH(..)
             | Terminal::After(..)
@@ -112,9 +113,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                     && c.real_for_each_key(pred)
             }
             Terminal::Thresh(_, ref subs) => subs.iter().all(|sub| sub.real_for_each_key(pred)),
-            Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => {
-                keys.iter().all(|key| pred(key))
-            }
+            Terminal::Multi(_, ref keys) => keys.iter().all(|key| pred(key)),
+            Terminal::MultiA(_, ref keys) => keys.iter().all(|key| key.for_each_key(&mut *pred)),
         }
     }
 
@@ -125,7 +125,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
         T: Translator<Pk, Q, E>,
     {
         let frag: Terminal<Q, CtxQ> = match *self {
-            Terminal::PkK(ref p) => Terminal::PkK(t.pk(p)?),
+            Terminal::PkK(ref p) => Terminal::PkK(p.translate_pk(t)?),
             Terminal::PkH(ref p) => Terminal::PkH(t.pk(p)?),
             Terminal::RawPkH(ref p) => Terminal::RawPkH(t.pkh(p)?),
             Terminal::After(n) => Terminal::After(n),
@@ -186,7 +186,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 Terminal::Multi(k, keys?)
             }
             Terminal::MultiA(k, ref keys) => {
-                let keys: Result<Vec<Q>, _> = keys.iter().map(|k| t.pk(k)).collect();
+                let keys: Result<Vec<KeyExpr<Q>>, _> =
+                    keys.iter().map(|k| k.translate_pk(t)).collect();
                 Terminal::MultiA(k, keys?)
             }
         };
@@ -455,7 +456,7 @@ impl_from_tree!(
         }
         let mut unwrapped = match (frag_name, top.args.len()) {
             ("pk_k", 1) => {
-                expression::terminal(&top.args[0], |x| Pk::from_str(x).map(Terminal::PkK))
+                expression::unary(top, Terminal::PkK)
             }
             ("pk_h", 1) => expression::terminal(&top.args[0], |x| Pk::from_str(x).map(Terminal::PkH)),
             ("after", 1) => expression::terminal(&top.args[0], |x| {
@@ -522,15 +523,18 @@ impl_from_tree!(
                     return Err(errstr("higher threshold than there were keys in multi"));
                 }
 
-                let pks: Result<Vec<Pk>, _> = top.args[1..]
-                    .iter()
-                    .map(|sub| expression::terminal(sub, Pk::from_str))
-                    .collect();
-
                 if frag_name == "multi" {
+                    let pks: Result<Vec<Pk>, _> = top.args[1..]
+                        .iter()
+                        .map(|sub| expression::terminal(sub, Pk::from_str))
+                        .collect();
                     pks.map(|pks| Terminal::Multi(k, pks))
                 } else {
                     // must be multi_a
+                    let pks: Result<Vec<KeyExpr<Pk>>, _> = top.args[1..]
+                        .iter()
+                        .map(|sub| expression::terminal(sub, KeyExpr::<Pk>::from_str))
+                        .collect();
                     pks.map(|pks| Terminal::MultiA(k, pks))
                 }
             }
@@ -734,7 +738,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 builder = builder.push_ms_key::<_, Ctx>(&keys[0]);
                 builder = builder.push_opcode(opcodes::all::OP_CHECKSIG);
                 for pk in keys.iter().skip(1) {
-                    builder = builder.push_ms_key::<_, Ctx>(pk);
+                    builder = builder.push_ms_key::<_, Ctx>(&pk);
                     builder = builder.push_opcode(opcodes::all::OP_CHECKSIGADD);
                 }
                 builder
@@ -793,7 +797,10 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 script_num_size(k)
                     + 1
                     + script_num_size(pks.len())
-                    + pks.iter().map(|pk| Ctx::pk_len(pk)).sum::<usize>()
+                    + pks
+                        .iter()
+                        .map(|pk| Ctx::pk_len(&KeyExpr::SingleKey(pk.clone())))
+                        .sum::<usize>()
             }
             Terminal::MultiA(k, ref pks) => {
                 script_num_size(k)