Introduce constructor for p2wpkh input pairs

Author: shinghim

payjoin/src/psbt/mod.rs

@@ -217,7 +217,7 @@ impl InternalInputPair<'_> {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum PrevTxOutError {
     MissingUtxoInformation,
     IndexOutOfBounds { output_count: usize, index: u32 },
@@ -236,14 +236,15 @@ impl fmt::Display for PrevTxOutError {
 
 impl std::error::Error for PrevTxOutError {}
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum InternalPsbtInputError {
     PrevTxOut(PrevTxOutError),
     UnequalTxid,
     /// TxOut provided in `segwit_utxo` doesn't match the one in `non_segwit_utxo`
     SegWitTxOutMismatch,
     AddressType(AddressTypeError),
     NoRedeemScript,
+    InvalidP2wpkhScriptPubkey,
 }
 
 impl fmt::Display for InternalPsbtInputError {
@@ -254,6 +255,7 @@ impl fmt::Display for InternalPsbtInputError {
             Self::SegWitTxOutMismatch => write!(f, "transaction output provided in SegWit UTXO field doesn't match the one in non-SegWit UTXO field"),
             Self::AddressType(_) => write!(f, "invalid address type"),
             Self::NoRedeemScript => write!(f, "provided p2sh PSBT input is missing a redeem_script"),
+            Self::InvalidP2wpkhScriptPubkey => write!(f, "provided script pubkey is invalid for P2WPKH")
         }
     }
 }
@@ -266,6 +268,7 @@ impl std::error::Error for InternalPsbtInputError {
             Self::SegWitTxOutMismatch => None,
             Self::AddressType(error) => Some(error),
             Self::NoRedeemScript => None,
+            Self::InvalidP2wpkhScriptPubkey => None,
         }
     }
 }
@@ -278,7 +281,7 @@ impl From<AddressTypeError> for InternalPsbtInputError {
     fn from(value: AddressTypeError) -> Self { Self::AddressType(value) }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct PsbtInputError(InternalPsbtInputError);
 
 impl From<InternalPsbtInputError> for PsbtInputError {
@@ -309,7 +312,7 @@ impl std::error::Error for PsbtInputsError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.error) }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum AddressTypeError {
     PrevTxOut(PrevTxOutError),
     InvalidScript(FromScriptError),

payjoin/src/receive/mod.rs

@@ -11,7 +11,7 @@
 
 use std::str::FromStr;
 
-use bitcoin::{psbt, AddressType, Psbt, TxIn, TxOut};
+use bitcoin::{psbt, AddressType, OutPoint, Psbt, TxIn, TxOut};
 pub(crate) use error::InternalPayloadError;
 pub use error::{
     Error, InputContributionError, JsonReply, OutputSubstitutionError, PayloadError,
@@ -58,6 +58,49 @@ impl InputPair {
         Ok(input_pair)
     }
 
+    /// Constructs a new ['InputPair'] for spending a native SegWit P2WPKH output
+    pub fn new_p2wpkh(txout: TxOut, outpoint: OutPoint) -> Result<Self, PsbtInputError> {
+        if !txout.script_pubkey.is_p2wpkh() {
+            return Err(InternalPsbtInputError::InvalidP2wpkhScriptPubkey.into());
+        }
+
+        let txin = TxIn {
+            previous_output: OutPoint { txid: outpoint.txid, vout: outpoint.vout },
+            script_sig: Default::default(),
+            sequence: Default::default(),
+            witness: Default::default(),
+        };
+
+        let psbtin = psbt::Input {
+            non_witness_utxo: None,
+            witness_utxo: Some(TxOut { value: txout.value, script_pubkey: txout.script_pubkey }),
+            partial_sigs: Default::default(),
+            sighash_type: None,
+            redeem_script: None,
+            witness_script: None,
+            bip32_derivation: Default::default(),
+            final_script_sig: None,
+            final_script_witness: None,
+            ripemd160_preimages: Default::default(),
+            sha256_preimages: Default::default(),
+            hash160_preimages: Default::default(),
+            hash256_preimages: Default::default(),
+            tap_key_sig: None,
+            tap_script_sigs: Default::default(),
+            tap_scripts: Default::default(),
+            tap_key_origins: Default::default(),
+            tap_internal_key: None,
+            tap_merkle_root: None,
+            proprietary: Default::default(),
+            unknown: Default::default(),
+        };
+        let input_pair = Self { txin, psbtin };
+        let raw = InternalInputPair::from(&input_pair);
+        raw.validate_utxo()?;
+
+        Ok(input_pair)
+    }
+
     pub(crate) fn previous_txout(&self) -> TxOut {
         InternalInputPair::from(self)
             .previous_txout()
@@ -88,3 +131,32 @@ pub(crate) fn parse_payload(
 
     Ok((psbt, params))
 }
+
+#[cfg(test)]
+mod tests {
+    use bitcoin::hashes::Hash;
+    use bitcoin::key::WPubkeyHash;
+    use bitcoin::{ScriptBuf, ScriptHash, Txid};
+
+    use super::*;
+    use crate::psbt::InternalPsbtInputError::InvalidP2wpkhScriptPubkey;
+
+    #[test]
+    fn create_p2wpkh_input_pair() {
+        let outpoint = OutPoint { txid: Txid::all_zeros(), vout: 0 };
+        let p2wpkh_txout = TxOut {
+            value: Default::default(),
+            script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::all_zeros()),
+        };
+        assert!(InputPair::new_p2wpkh(p2wpkh_txout, outpoint).is_ok());
+
+        let p2sh_txout = TxOut {
+            value: Default::default(),
+            script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()),
+        };
+        assert_eq!(
+            InputPair::new_p2wpkh(p2sh_txout, outpoint).err().unwrap(),
+            PsbtInputError::from(InvalidP2wpkhScriptPubkey)
+        )
+    }
+}