|
11 | 11 |
|
12 | 12 | use std::str::FromStr; |
13 | 13 |
|
14 | | -use bitcoin::{psbt, AddressType, Psbt, TxIn, TxOut}; |
| 14 | +use bitcoin::{psbt, AddressType, OutPoint, Psbt, ScriptBuf, Sequence, TxIn, TxOut}; |
15 | 15 | pub(crate) use error::InternalPayloadError; |
16 | 16 | pub use error::{ |
17 | 17 | Error, InputContributionError, JsonReply, OutputSubstitutionError, PayloadError, |
@@ -58,6 +58,72 @@ impl InputPair { |
58 | 58 | Ok(input_pair) |
59 | 59 | } |
60 | 60 |
|
| 61 | + /// Helper function for creating SegWit input pairs |
| 62 | + fn new_segwit_input_pair( |
| 63 | + txout: TxOut, |
| 64 | + outpoint: OutPoint, |
| 65 | + sequence: Option<Sequence>, |
| 66 | + witness_script: Option<ScriptBuf>, |
| 67 | + ) -> Result<Self, PsbtInputError> { |
| 68 | + let txin = TxIn { |
| 69 | + previous_output: OutPoint { txid: outpoint.txid, vout: outpoint.vout }, |
| 70 | + script_sig: Default::default(), |
| 71 | + sequence: sequence.unwrap_or_default(), |
| 72 | + witness: Default::default(), |
| 73 | + }; |
| 74 | + |
| 75 | + let psbtin = psbt::Input { |
| 76 | + witness_utxo: Some(TxOut { value: txout.value, script_pubkey: txout.script_pubkey }), |
| 77 | + witness_script, |
| 78 | + ..psbt::Input::default() |
| 79 | + }; |
| 80 | + let input_pair = Self { txin, psbtin }; |
| 81 | + let raw = InternalInputPair::from(&input_pair); |
| 82 | + raw.validate_utxo()?; |
| 83 | + |
| 84 | + Ok(input_pair) |
| 85 | + } |
| 86 | + |
| 87 | + /// Constructs a new ['InputPair'] for spending a native SegWit P2WPKH output |
| 88 | + pub fn new_p2wpkh( |
| 89 | + txout: TxOut, |
| 90 | + outpoint: OutPoint, |
| 91 | + sequence: Option<Sequence>, |
| 92 | + ) -> Result<Self, PsbtInputError> { |
| 93 | + if !txout.script_pubkey.is_p2wpkh() { |
| 94 | + return Err(InternalPsbtInputError::InvalidP2wpkhScriptPubkey.into()); |
| 95 | + } |
| 96 | + |
| 97 | + Self::new_segwit_input_pair(txout, outpoint, sequence, None) |
| 98 | + } |
| 99 | + |
| 100 | + /// Constructs a new ['InputPair'] for spending a native SegWit P2WSH output |
| 101 | + pub fn new_p2wsh( |
| 102 | + txout: TxOut, |
| 103 | + outpoint: OutPoint, |
| 104 | + witness_script: ScriptBuf, |
| 105 | + sequence: Option<Sequence>, |
| 106 | + ) -> Result<Self, PsbtInputError> { |
| 107 | + if !txout.script_pubkey.is_p2wsh() { |
| 108 | + return Err(InternalPsbtInputError::InvalidP2wshScriptPubkey.into()); |
| 109 | + } |
| 110 | + |
| 111 | + Self::new_segwit_input_pair(txout, outpoint, sequence, Some(witness_script)) |
| 112 | + } |
| 113 | + |
| 114 | + /// Constructs a new ['InputPair'] for spending a native SegWit P2TR output |
| 115 | + pub fn new_p2tr( |
| 116 | + txout: TxOut, |
| 117 | + outpoint: OutPoint, |
| 118 | + sequence: Option<Sequence>, |
| 119 | + ) -> Result<Self, PsbtInputError> { |
| 120 | + if !txout.script_pubkey.is_p2tr() { |
| 121 | + return Err(InternalPsbtInputError::InvalidP2trScriptPubkey.into()); |
| 122 | + } |
| 123 | + |
| 124 | + Self::new_segwit_input_pair(txout, outpoint, sequence, None) |
| 125 | + } |
| 126 | + |
61 | 127 | pub(crate) fn previous_txout(&self) -> TxOut { |
62 | 128 | InternalInputPair::from(self) |
63 | 129 | .previous_txout() |
@@ -88,3 +154,102 @@ pub(crate) fn parse_payload( |
88 | 154 |
|
89 | 155 | Ok((psbt, params)) |
90 | 156 | } |
| 157 | + |
| 158 | +#[cfg(test)] |
| 159 | +mod tests { |
| 160 | + use bitcoin::blockdata::script::Builder; |
| 161 | + use bitcoin::hashes::Hash; |
| 162 | + use bitcoin::key::{PublicKey, WPubkeyHash}; |
| 163 | + use bitcoin::opcodes::OP_TRUE; |
| 164 | + use bitcoin::secp256k1::Secp256k1; |
| 165 | + use bitcoin::{Amount, ScriptBuf, ScriptHash, Txid, WScriptHash, XOnlyPublicKey}; |
| 166 | + use payjoin_test_utils::{DUMMY20, DUMMY32}; |
| 167 | + |
| 168 | + use super::*; |
| 169 | + use crate::psbt::InternalPsbtInputError::{ |
| 170 | + InvalidP2trScriptPubkey, InvalidP2wpkhScriptPubkey, InvalidP2wshScriptPubkey, |
| 171 | + }; |
| 172 | + |
| 173 | + #[test] |
| 174 | + fn create_p2wpkh_input_pair() { |
| 175 | + let outpoint = OutPoint { txid: Txid::from_byte_array(DUMMY32), vout: 31 }; |
| 176 | + let sequence = Sequence::from_512_second_intervals(123); |
| 177 | + let p2wpkh_txout = TxOut { |
| 178 | + value: Amount::from_sat(12345), |
| 179 | + script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::from_byte_array(DUMMY20)), |
| 180 | + }; |
| 181 | + let p2wpkh_pair = |
| 182 | + InputPair::new_p2wpkh(p2wpkh_txout.clone(), outpoint, Some(sequence)).unwrap(); |
| 183 | + assert_eq!(p2wpkh_pair.txin.previous_output, outpoint); |
| 184 | + assert_eq!(p2wpkh_pair.txin.sequence, sequence); |
| 185 | + assert_eq!(p2wpkh_pair.psbtin.witness_utxo.unwrap(), p2wpkh_txout); |
| 186 | + |
| 187 | + let p2sh_txout = TxOut { |
| 188 | + value: Default::default(), |
| 189 | + script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()), |
| 190 | + }; |
| 191 | + assert_eq!( |
| 192 | + InputPair::new_p2wpkh(p2sh_txout, outpoint, Some(sequence)).err().unwrap(), |
| 193 | + PsbtInputError::from(InvalidP2wpkhScriptPubkey) |
| 194 | + ) |
| 195 | + } |
| 196 | + |
| 197 | + #[test] |
| 198 | + fn create_p2wsh_input_pair() { |
| 199 | + let outpoint = OutPoint { txid: Txid::from_byte_array(DUMMY32), vout: 31 }; |
| 200 | + let sequence = Sequence::from_512_second_intervals(123); |
| 201 | + let p2wsh_txout = TxOut { |
| 202 | + value: Amount::from_sat(12345), |
| 203 | + script_pubkey: ScriptBuf::new_p2wsh(&WScriptHash::from_byte_array(DUMMY32)), |
| 204 | + }; |
| 205 | + let witness_script = Builder::new().push_opcode(OP_TRUE).into_script(); |
| 206 | + let p2wsh_pair = InputPair::new_p2wsh( |
| 207 | + p2wsh_txout.clone(), |
| 208 | + outpoint, |
| 209 | + witness_script.clone(), |
| 210 | + Some(sequence), |
| 211 | + ) |
| 212 | + .unwrap(); |
| 213 | + assert_eq!(p2wsh_pair.txin.previous_output, outpoint); |
| 214 | + assert_eq!(p2wsh_pair.txin.sequence, sequence); |
| 215 | + assert_eq!(p2wsh_pair.psbtin.witness_utxo.unwrap(), p2wsh_txout); |
| 216 | + assert_eq!(p2wsh_pair.psbtin.witness_script.unwrap(), witness_script); |
| 217 | + |
| 218 | + let p2sh_txout = TxOut { |
| 219 | + value: Default::default(), |
| 220 | + script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()), |
| 221 | + }; |
| 222 | + assert_eq!( |
| 223 | + InputPair::new_p2wsh(p2sh_txout, outpoint, witness_script, Some(sequence)) |
| 224 | + .err() |
| 225 | + .unwrap(), |
| 226 | + PsbtInputError::from(InvalidP2wshScriptPubkey) |
| 227 | + ) |
| 228 | + } |
| 229 | + |
| 230 | + #[test] |
| 231 | + fn create_p2tr_input_pair() { |
| 232 | + let outpoint = OutPoint { txid: Txid::from_byte_array(DUMMY32), vout: 31 }; |
| 233 | + let sequence = Sequence::from_512_second_intervals(123); |
| 234 | + let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; |
| 235 | + let pubkey = pubkey_string.parse::<PublicKey>().expect("valid pubkey"); |
| 236 | + let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner); |
| 237 | + let p2tr_txout = TxOut { |
| 238 | + value: Amount::from_sat(12345), |
| 239 | + script_pubkey: ScriptBuf::new_p2tr(&Secp256k1::new(), xonly_pubkey, None), |
| 240 | + }; |
| 241 | + let p2tr_pair = InputPair::new_p2tr(p2tr_txout.clone(), outpoint, Some(sequence)).unwrap(); |
| 242 | + assert_eq!(p2tr_pair.txin.previous_output, outpoint); |
| 243 | + assert_eq!(p2tr_pair.txin.sequence, sequence); |
| 244 | + assert_eq!(p2tr_pair.psbtin.witness_utxo.unwrap(), p2tr_txout); |
| 245 | + |
| 246 | + let p2sh_txout = TxOut { |
| 247 | + value: Default::default(), |
| 248 | + script_pubkey: ScriptBuf::new_p2sh(&ScriptHash::all_zeros()), |
| 249 | + }; |
| 250 | + assert_eq!( |
| 251 | + InputPair::new_p2tr(p2sh_txout, outpoint, Some(sequence)).err().unwrap(), |
| 252 | + PsbtInputError::from(InvalidP2trScriptPubkey) |
| 253 | + ) |
| 254 | + } |
| 255 | +} |
0 commit comments