Change Semantic KeyHash(Pk::Hash) to Key(Pk)

This is one of the major breaking changes touching the parsing/display
and logic of semantic policies. This should only affect the
application/analysis layer of things, so it is okay to break somethings
here for code clarity.

My understanding is that will also help the simplicity bridge

Author: sanket1729

examples/htlc.rs

@@ -48,7 +48,7 @@ fn main() {
     // Lift the descriptor into an abstract policy.
     assert_eq!(
         format!("{}", htlc_descriptor.lift().unwrap()),
-        "or(and(pkh(4377a5acd66dc5cb67148a24818d1e51fa183bd2),sha256(1111111111111111111111111111111111111111111111111111111111111111)),and(pkh(51814f108670aced2d77c1805ddd6634bc9d4731),older(4444)))"
+"or(and(pk(022222222222222222222222222222222222222222222222222222222222222222),sha256(1111111111111111111111111111111111111111111111111111111111111111)),and(pk(020202020202020202020202020202020202020202020202020202020202020202),older(4444)))"
     );
 
     // Get the scriptPpubkey for this Wsh descriptor.

src/descriptor/bare.rs

@@ -294,7 +294,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Pkh<Pk> {
 
 impl<Pk: MiniscriptKey> Liftable<Pk> for Pkh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
-        Ok(semantic::Policy::KeyHash(self.pk.to_pubkeyhash()))
+        Ok(semantic::Policy::Key(self.pk.clone()))
     }
 }
 

src/descriptor/segwitv0.rs

@@ -407,7 +407,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Wpkh<Pk> {
 
 impl<Pk: MiniscriptKey> Liftable<Pk> for Wpkh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
-        Ok(semantic::Policy::KeyHash(self.pk.to_pubkeyhash()))
+        Ok(semantic::Policy::Key(self.pk.clone()))
     }
 }
 

src/descriptor/sh.rs

@@ -59,7 +59,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Sh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         match self.inner {
             ShInner::Wsh(ref wsh) => wsh.lift(),
-            ShInner::Wpkh(ref pk) => Ok(semantic::Policy::KeyHash(pk.as_inner().to_pubkeyhash())),
+            ShInner::Wpkh(ref pk) => Ok(semantic::Policy::Key(pk.as_inner().clone())),
             ShInner::SortedMulti(ref smv) => smv.lift(),
             ShInner::Ms(ref ms) => ms.lift(),
         }

src/descriptor/sortedmulti.rs

@@ -216,9 +216,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> policy::Liftable<Pk> for SortedMulti
         let ret = policy::semantic::Policy::Threshold(
             self.k,
             self.pks
-                .clone()
-                .into_iter()
-                .map(|k| policy::semantic::Policy::KeyHash(k.to_pubkeyhash()))
+                .iter()
+                .map(|k| policy::semantic::Policy::Key(k.clone()))
                 .collect(),
         );
         Ok(ret)

src/descriptor/tr.rs

@@ -548,12 +548,9 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
         match &self.tree {
             Some(root) => Ok(Policy::Threshold(
                 1,
-                vec![
-                    Policy::KeyHash(self.internal_key.to_pubkeyhash()),
-                    root.lift()?,
-                ],
+                vec![Policy::Key(self.internal_key.clone()), root.lift()?],
             )),
-            None => Ok(Policy::KeyHash(self.internal_key.to_pubkeyhash())),
+            None => Ok(Policy::Key(self.internal_key.clone())),
         }
     }
 }

src/policy/concrete.rs

@@ -353,7 +353,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             for key in concrete_keys.into_iter() {
                 if semantic_policy
                     .clone()
-                    .satisfy_constraint(&Semantic::KeyHash(key.to_pubkeyhash()), true)
+                    .satisfy_constraint(&Semantic::Key(key.clone()), true)
                     == Semantic::Trivial
                 {
                     match key_prob_map.get(&Concrete::Key(key.clone())) {

src/policy/mod.rs

@@ -66,6 +66,8 @@ pub enum LiftError {
     HeightTimelockCombination,
     /// Duplicate Public Keys
     BranchExceedResourceLimits,
+    /// Cannot lift raw descriptors
+    RawDescriptorLift,
 }
 
 impl fmt::Display for LiftError {
@@ -77,6 +79,7 @@ impl fmt::Display for LiftError {
             LiftError::BranchExceedResourceLimits => f.write_str(
                 "Cannot lift policies containing one branch that exceeds resource limits",
             ),
+            LiftError::RawDescriptorLift => f.write_str("Cannot lift raw descriptors"),
         }
     }
 }
@@ -87,7 +90,7 @@ impl error::Error for LiftError {
         use self::LiftError::*;
 
         match self {
-            HeightTimelockCombination | BranchExceedResourceLimits => None,
+            HeightTimelockCombination | BranchExceedResourceLimits | RawDescriptorLift => None,
         }
     }
 }
@@ -124,8 +127,10 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx>
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         let ret = match *self {
-            Terminal::PkK(ref pk) | Terminal::PkH(ref pk) => Semantic::KeyHash(pk.to_pubkeyhash()),
-            Terminal::RawPkH(ref pkh) => Semantic::KeyHash(pkh.clone()),
+            Terminal::PkK(ref pk) | Terminal::PkH(ref pk) => Semantic::Key(pk.clone()),
+            Terminal::RawPkH(ref _pkh) => {
+                return Err(Error::LiftError(LiftError::RawDescriptorLift))
+            }
             Terminal::After(t) => Semantic::After(t),
             Terminal::Older(t) => Semantic::Older(t),
             Terminal::Sha256(ref h) => Semantic::Sha256(h.clone()),
@@ -161,12 +166,9 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
                 let semantic_subs: Result<_, Error> = subs.iter().map(|s| s.node.lift()).collect();
                 Semantic::Threshold(k, semantic_subs?)
             }
-            Terminal::Multi(k, ref keys) | Terminal::MultiA(k, ref keys) => Semantic::Threshold(
-                k,
-                keys.iter()
-                    .map(|k| Semantic::KeyHash(k.to_pubkeyhash()))
-                    .collect(),
-            ),
+            Terminal::Multi(k, ref keys) | Terminal::MultiA(k, ref keys) => {
+                Semantic::Threshold(k, keys.iter().map(|k| Semantic::Key(k.clone())).collect())
+            }
         }
         .normalized();
         Ok(ret)
@@ -200,7 +202,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
         let ret = match *self {
             Concrete::Unsatisfiable => Semantic::Unsatisfiable,
             Concrete::Trivial => Semantic::Trivial,
-            Concrete::Key(ref pk) => Semantic::KeyHash(pk.to_pubkeyhash()),
+            Concrete::Key(ref pk) => Semantic::Key(pk.clone()),
             Concrete::After(t) => Semantic::After(t),
             Concrete::Older(t) => Semantic::Older(t),
             Concrete::Sha256(ref h) => Semantic::Sha256(h.clone()),
@@ -281,9 +283,9 @@ mod tests {
         concrete_policy_rtt("or(99@pk(),1@pk())");
         concrete_policy_rtt("and(pk(),or(99@pk(),1@older(12960)))");
 
-        semantic_policy_rtt("pkh()");
-        semantic_policy_rtt("or(pkh(),pkh())");
-        semantic_policy_rtt("and(pkh(),pkh())");
+        semantic_policy_rtt("pk()");
+        semantic_policy_rtt("or(pk(),pk())");
+        semantic_policy_rtt("and(pk(),pk())");
 
         //fuzzer crashes
         assert!(ConcretePol::from_str("thresh()").is_err());
@@ -362,11 +364,11 @@ mod tests {
                     Semantic::Threshold(
                         2,
                         vec![
-                            Semantic::KeyHash(key_a.pubkey_hash().as_hash()),
+                            Semantic::Key(key_a),
                             Semantic::Older(Sequence::from_height(42))
                         ]
                     ),
-                    Semantic::KeyHash(key_b.pubkey_hash().as_hash())
+                    Semantic::Key(key_b)
                 ]
             ),
             ms_str.lift().unwrap()