refactor(silentpayments): match SpInput and bitcoin::psbt::OutputType variants

Author: nymius

silentpayments/src/lib.rs

@@ -20,10 +20,14 @@ pub const NUMS_H: [u8; 32] = [
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum SpInputs {
-    P2TR,
-    P2WPKH,
-    WrappedSegwit,
-    P2PKH,
+    /// The input spends a P2TR output.
+    Tr,
+    /// The input spends a P2WPKH output.
+    Wpkh,
+    /// The input spends a P2WPKH output nested in a P2SH.
+    ShWpkh,
+    /// The inputs spends a P2PKH output.
+    Pkh,
 }
 
 pub fn tag_txin(txin: &TxIn, script_pubkey: &ScriptBuf) -> Option<SpInputs> {
@@ -36,12 +40,12 @@ pub fn tag_txin(txin: &TxIn, script_pubkey: &ScriptBuf) -> Option<SpInputs> {
             .redeem_script()
             .filter(|script_pubkey| script_pubkey.is_p2wpkh())
             // if not P2SH-P2WPKH return None
-            .map(|_| WrappedSegwit),
+            .map(|_| ShWpkh),
         // Native segwit
         (false, true) => {
             // P2WPKH
             if script_pubkey.is_p2wpkh() {
-                Some(P2WPKH)
+                Some(Wpkh)
             } else {
                 // P2TR
                 script_pubkey
@@ -51,13 +55,13 @@ pub fn tag_txin(txin: &TxIn, script_pubkey: &ScriptBuf) -> Option<SpInputs> {
                             .taproot_control_block()
                             .filter(|control_block| control_block[1..33] == NUMS_H)
                             // if P2TR has no internal key return None
-                            .map_or(Some(P2TR), |_| None)
+                            .map_or(Some(Tr), |_| None)
                     })
                     .flatten()
             }
         }
         // No witness, legacy P2PKH
-        (true, false) if script_pubkey.is_p2pkh() => Some(P2PKH),
+        (true, false) if script_pubkey.is_p2pkh() => Some(Pkh),
         // All other cases
         _ => None,
     }
@@ -166,7 +170,7 @@ mod tests {
 
         let tagged_input = tag_txin(&txin, &script_pubkey);
 
-        assert_eq!(Some(SpInputs::WrappedSegwit), tagged_input);
+        assert_eq!(Some(SpInputs::ShWpkh), tagged_input);
     }
 
     #[test]
@@ -217,7 +221,7 @@ mod tests {
 
         let tagged_input = tag_txin(&txin, &script_pubkey);
 
-        assert_eq!(Some(SpInputs::P2TR), tagged_input);
+        assert_eq!(Some(SpInputs::Tr), tagged_input);
     }
 
     #[test]
@@ -273,7 +277,7 @@ mod tests {
 
         let tagged_input = tag_txin(&txin, &script_pubkey);
 
-        assert_eq!(Some(SpInputs::P2WPKH), tagged_input);
+        assert_eq!(Some(SpInputs::Wpkh), tagged_input);
     }
 
     #[test]
@@ -322,7 +326,7 @@ mod tests {
 
         let tagged_input = tag_txin(&txin, &script_pubkey);
 
-        assert_eq!(Some(SpInputs::P2PKH), tagged_input);
+        assert_eq!(Some(SpInputs::Pkh), tagged_input);
     }
 
     #[test]

silentpayments/src/receive/mod.rs

@@ -54,17 +54,17 @@ pub fn extract_pubkey(txin: TxIn, script_pubkey: &ScriptBuf) -> Option<(SpInputs
     use SpInputs::*;
 
     tag_txin(&txin, script_pubkey).and_then(|tag| match tag {
-        WrappedSegwit | P2WPKH => {
+        ShWpkh | Wpkh => {
             let maybe_pk = txin.witness.last().expect("already checked is not empty");
             bitcoin::PublicKey::from_slice(maybe_pk)
                 .ok()
                 .filter(|pubkey| pubkey.compressed)
                 .map(|pk| (tag, pk.inner))
         }
-        P2TR => XOnlyPublicKey::from_slice(&script_pubkey.as_bytes()[2..34])
+        Tr => XOnlyPublicKey::from_slice(&script_pubkey.as_bytes()[2..34])
             .ok()
             .map(|xonly_pk| (tag, xonly_pk.public_key(Parity::Even))),
-        P2PKH => txin
+        Pkh => txin
             .script_sig
             .into_bytes()
             .windows(33)
@@ -304,7 +304,7 @@ mod tests {
 
         let (input_type, parsed_pubkey) = maybe_pubkey.expect("is some");
 
-        assert_eq!(SpInputs::WrappedSegwit, input_type);
+        assert_eq!(SpInputs::ShWpkh, input_type);
 
         assert_eq!(expected_pubkey, parsed_pubkey);
     }
@@ -339,7 +339,7 @@ mod tests {
 
         let (input_type, parsed_pubkey) = maybe_pubkey.expect("is some");
 
-        assert_eq!(SpInputs::P2WPKH, input_type);
+        assert_eq!(SpInputs::Wpkh, input_type);
 
         assert_eq!(expected_pubkey, parsed_pubkey);
     }
@@ -376,7 +376,7 @@ mod tests {
 
         let (input_type, parsed_pubkey) = maybe_pubkey.expect("is some");
 
-        assert_eq!(SpInputs::P2TR, input_type);
+        assert_eq!(SpInputs::Tr, input_type);
 
         assert_eq!(expected_pubkey, parsed_pubkey);
     }
@@ -409,7 +409,7 @@ mod tests {
 
         let (input_type, parsed_pubkey) = maybe_pubkey.expect("is some");
 
-        assert_eq!(SpInputs::P2PKH, input_type);
+        assert_eq!(SpInputs::Pkh, input_type);
 
         assert_eq!(expected_pubkey, parsed_pubkey);
     }
@@ -443,7 +443,7 @@ mod tests {
 
         let (input_type, parsed_pubkey) = maybe_pubkey.expect("is some");
 
-        assert_eq!(SpInputs::P2PKH, input_type);
+        assert_eq!(SpInputs::Pkh, input_type);
 
         assert_eq!(expected_pubkey, parsed_pubkey);
     }

silentpayments/src/send/psbt.rs

@@ -51,7 +51,7 @@ where
         }
 
         if let Some((input_type, _pk)) = extract_pubkey(full_txin, &prevout) {
-            if let SpInputs::P2TR = input_type {
+            if let SpInputs::Tr = input_type {
                 for (&xonly, (_leaf_hashes, key_source)) in psbt_input.tap_key_origins.iter() {
                     let mut internal_privkey = if let Ok(Some(privkey)) =
                         k.get_key(KeyRequest::Bip32(key_source.clone()), secp)