From 1c379531ae2000a71239010cce9082d4976a795c Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 17 Jun 2026 22:09:53 +0200 Subject: [PATCH 01/13] refactor: pass the smallest outpoint to `calculate_input_hash` Callers supply the minimum outpoint. Later shared-secret constructors pass `TransactionInputs::min_outpoint` instead of a `NonEmptyArray`. --- silentpayments/src/utils/hash.rs | 12 ++++-------- silentpayments/src/utils/receiving.rs | 2 +- silentpayments/src/utils/sending.rs | 2 +- 3 files changed, 6 insertions(+), 10 deletions(-) diff --git a/silentpayments/src/utils/hash.rs b/silentpayments/src/utils/hash.rs index 081db4b6..17461e07 100644 --- a/silentpayments/src/utils/hash.rs +++ b/silentpayments/src/utils/hash.rs @@ -1,8 +1,7 @@ -use bitcoin_hashes::{Hash as _, HashEngine as _, sha256t_hash_newtype}; +use crate::utils::common::{OutPoint, SharedSecret}; +use bitcoin_hashes::{Hash, HashEngine, sha256t_hash_newtype}; use secp256k1::{PublicKey, Scalar, SecretKey}; -use crate::utils::common::{NonEmptyArray, OutPoint, SharedSecret}; - sha256t_hash_newtype! { struct InputsTag = hash_str("BIP0352/Inputs"); @@ -66,9 +65,6 @@ impl SharedSecretHash { } } -pub(crate) fn calculate_input_hash( - outpoints_data: &NonEmptyArray, - A_sum: PublicKey, -) -> Scalar { - InputsHash::from_outpoint_and_A_sum(outpoints_data.min(), A_sum).to_scalar() +pub(crate) fn calculate_input_hash(smaller_outpoint: &OutPoint, A_sum: PublicKey) -> Scalar { + InputsHash::from_outpoint_and_A_sum(smaller_outpoint, A_sum).to_scalar() } diff --git a/silentpayments/src/utils/receiving.rs b/silentpayments/src/utils/receiving.rs index bd3bec14..c8355132 100644 --- a/silentpayments/src/utils/receiving.rs +++ b/silentpayments/src/utils/receiving.rs @@ -92,7 +92,7 @@ pub fn calculate_tweak_data( let A_sum = PublicKey::combine_keys(input_pub_keys)?; let outpoints = NonEmptyArray::new(outpoints_data)?; - let input_hash = calculate_input_hash(&outpoints, A_sum); + let input_hash = calculate_input_hash(outpoints.min(), A_sum); Ok(A_sum.mul_tweak(&secp, &input_hash)?) } diff --git a/silentpayments/src/utils/sending.rs b/silentpayments/src/utils/sending.rs index c3e978b2..e24affb5 100644 --- a/silentpayments/src/utils/sending.rs +++ b/silentpayments/src/utils/sending.rs @@ -68,7 +68,7 @@ pub fn calculate_partial_secret( let A_sum = a_sum.public_key(&secp); let outpoints = NonEmptyArray::new(outpoints_data)?; - let input_hash = calculate_input_hash(&outpoints, A_sum); + let input_hash = calculate_input_hash(outpoints.min(), A_sum); Ok(PartialSecret(a_sum.mul_tweak(&input_hash)?)) } From f03a9ea71a64cf63fb348465a087fba0438a3f03 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 17 Jun 2026 22:09:01 +0200 Subject: [PATCH 02/13] feat: add `TransactionInputs` type --- silentpayments/src/lib.rs | 2 + silentpayments/src/utils/common.rs | 97 ++++++++++++++++++++++++++++-- 2 files changed, 95 insertions(+), 4 deletions(-) diff --git a/silentpayments/src/lib.rs b/silentpayments/src/lib.rs index 51c7fb00..698308b8 100644 --- a/silentpayments/src/lib.rs +++ b/silentpayments/src/lib.rs @@ -21,5 +21,7 @@ pub use utils::common::SilentPaymentCode; pub use utils::common::{Network, SilentPaymentKeyMaterial, SpVersion}; pub use crate::error::Error; +#[cfg(any(feature = "sending", feature = "receiving"))] +pub use utils::common::TransactionInputs; pub type Result = std::result::Result; diff --git a/silentpayments/src/utils/common.rs b/silentpayments/src/utils/common.rs index 85a33977..7b6c9fcc 100644 --- a/silentpayments/src/utils/common.rs +++ b/silentpayments/src/utils/common.rs @@ -3,6 +3,12 @@ use core::fmt; #[cfg(feature = "encode")] use core::str::FromStr; +use crate::Error; +use crate::Result; +#[cfg(any(feature = "sending", feature = "receiving"))] +use crate::utils::hash::SharedSecretHash; +#[cfg(any(feature = "sending", feature = "receiving"))] +use crate::utils::script::is_eligible; #[cfg(feature = "encode")] use bech32::Variant; #[cfg(feature = "encode")] @@ -14,10 +20,6 @@ use secp256k1::constants::PUBLIC_KEY_SIZE; #[cfg(any(feature = "sending", feature = "receiving"))] use secp256k1::{Scalar, Secp256k1, SecretKey}; -#[cfg(any(feature = "sending", feature = "receiving"))] -use crate::utils::hash::SharedSecretHash; -use crate::{Error, Result}; - /// Struct representing an `OutPoint` type. /// /// This can be constructed from a rust-bitcoin outpoint: @@ -87,6 +89,93 @@ impl OutPoint { } } +/// Parallel per-vin input data for BIP352 shared secret derivation. +/// +/// All fields are indexed by input vin. Use [`Self::new`] and [`Self::push`] when building +/// from chain data. +#[cfg(any(feature = "sending", feature = "receiving"))] +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct TransactionInputs { + outpoints: Vec, + script_pubkeys: Vec>, + input_pubkeys: Vec>, +} + +#[cfg(any(feature = "sending", feature = "receiving"))] +#[expect(clippy::missing_const_for_fn)] +impl TransactionInputs { + /// Create an empty input set for incremental construction. + pub fn new() -> Self { + Self::default() + } + + pub fn with_capacity(capacity: usize) -> Self { + Self { + outpoints: Vec::with_capacity(capacity), + script_pubkeys: Vec::with_capacity(capacity), + input_pubkeys: Vec::with_capacity(capacity), + } + } + + /// Append one transaction input. + pub fn push( + &mut self, + outpoint: OutPoint, + script_pubkey: Vec, + input_pubkey: Option, + ) { + self.outpoints.push(outpoint); + self.script_pubkeys.push(script_pubkey); + self.input_pubkeys.push(input_pubkey); + } + + pub fn len(&self) -> usize { + self.outpoints.len() + } + + pub fn is_empty(&self) -> bool { + self.outpoints.is_empty() + } + + pub fn outpoints(&self) -> &[OutPoint] { + &self.outpoints + } + + pub fn script_pubkeys(&self) -> &[Vec] { + &self.script_pubkeys + } + + pub fn input_pubkeys(&self) -> &[Option] { + &self.input_pubkeys + } + + pub fn input_pubkey(&self, vin: usize) -> Option<&PublicKey> { + self.input_pubkeys.get(vin).and_then(|pk| pk.as_ref()) + } + + pub(crate) fn min_outpoint(&self) -> &OutPoint { + self.outpoints.iter().min().expect("non-empty") + } + + pub(crate) fn eligible_pubkeys(&self) -> Result> { + let eligible: Vec<&PublicKey> = self + .script_pubkeys + .iter() + .zip(&self.input_pubkeys) + .filter_map(|(spk, pk)| pk.as_ref().filter(|_| is_eligible(spk))) + .collect(); + if eligible.is_empty() { + return Err(Error::GenericError("No eligible input pubkeys".to_owned())); + } + Ok(eligible) + } + + pub(crate) fn eligible_pubkeys_sum(&self) -> Result { + let eligible_pubkeys = self.eligible_pubkeys()?; + Ok(PublicKey::combine_keys(&eligible_pubkeys)?) + } +} + #[cfg(any(feature = "sending", feature = "receiving"))] #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)] pub struct SharedSecret(pub(crate) PublicKey); From 215244a72a7057747537164bd3f3d95b95fdfbf2 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Thu, 18 Jun 2026 10:19:08 +0200 Subject: [PATCH 03/13] refactor: redesign shared-secret types around TransactionSharedSecret Replace SharedSecret (PublicKey newtype) with TransactionSharedSecret, which carries both the ECDH shared secret and the recipient scan key. Introduce PublicTweakData in place of calculate_tweak_data / calculate_ecdh_shared_secret, add ecdh_multiply and NormalizedSecretKey, and migrate receiving/sending callers (scanners, wallet, examples, tests). --- scanners/local/src/scanner.rs | 17 +++-- silentpayments/examples/find_output.rs | 78 +++++++------------ silentpayments/src/lib.rs | 11 +-- silentpayments/src/receiving.rs | 29 ++++--- silentpayments/src/sending.rs | 7 +- silentpayments/src/utils/common.rs | 102 +++++++++++++++++++++---- silentpayments/src/utils/hash.rs | 20 +++-- silentpayments/src/utils/receiving.rs | 94 ++++++++++------------- silentpayments/src/utils/sending.rs | 73 +++++++++++------- silentpayments/tests/vector_tests.rs | 46 ++++++----- spdk-wallet/Cargo.toml | 3 +- spdk-wallet/src/client/client.rs | 52 ++++++++++++- 12 files changed, 323 insertions(+), 209 deletions(-) diff --git a/scanners/local/src/scanner.rs b/scanners/local/src/scanner.rs index 87e16437..b10ad16b 100644 --- a/scanners/local/src/scanner.rs +++ b/scanners/local/src/scanner.rs @@ -5,16 +5,15 @@ use std::time::Instant; use anyhow::Result; use bitcoin::absolute::Height; +use bitcoin::key::Secp256k1; use bitcoin::secp256k1::{PublicKey, Scalar, SecretKey}; use bitcoin::{Amount, OutPoint, ScriptBuf, TxOut, Txid, XOnlyPublicKey}; use futures::channel::mpsc::{Receiver, Sender, channel}; use futures::{SinkExt as _, Stream, StreamExt as _, pin_mut}; use log::{info, warn}; -use silentpayments::SharedSecret; +use silentpayments::TransactionSharedSecret; use silentpayments::receiving::{Label, Receiver as SpReceiver}; -use silentpayments::utils::receiving::{ - calculate_ecdh_shared_secret, generate_script_pubkey_from_output_key, -}; +use silentpayments::utils::receiving::{PublicTweakData, generate_script_pubkey_from_output_key}; use spdk_core::chain::{BoxedBlockData, BoxedChainBackend, UtxoData}; use spdk_core::scanner::{DiscoveredOutput, ScanResult, Scanner}; use tokio::task; @@ -250,7 +249,7 @@ async fn process_block_inputs( async fn scan_utxos( backend: &BoxedChainBackend, blkheight: Height, - secrets_map: HashMap, + secrets_map: HashMap, sp_receiver: &SpReceiver, ) -> Result, UtxoData, Scalar)>> { let utxos = backend.utxos(blkheight).await?; @@ -301,7 +300,7 @@ pub fn output_key_to_secret_map( b_scan: &SecretKey, sp_receiver: &SpReceiver, tweak_data_vec: Vec, -) -> Result> { +) -> Result> { // if using rayon feature, import the preludes #[cfg(feature = "rayon")] use rayon::prelude::*; @@ -314,9 +313,13 @@ pub fn output_key_to_secret_map( #[cfg(not(feature = "rayon"))] let tweak_data_iterator = tweak_data_vec.into_iter(); + let secp = &Secp256k1::new(); + let items: Result> = tweak_data_iterator .map(|tweak| { - let secret = calculate_ecdh_shared_secret(&tweak, b_scan); + let tweak_data = PublicTweakData::new_unchecked(tweak); + let secret = + TransactionSharedSecret::new_from_public_tweak_data(secp, &tweak_data, b_scan)?; let output_keys = sp_receiver.generate_output_keys_from_shared_secret(&secret)?; Ok((secret, output_keys.into_values())) diff --git a/silentpayments/examples/find_output.rs b/silentpayments/examples/find_output.rs index 1d87bf33..fe48f8de 100644 --- a/silentpayments/examples/find_output.rs +++ b/silentpayments/examples/find_output.rs @@ -2,36 +2,31 @@ use std::env; use std::error::Error; use std::str::FromStr as _; -// Import necessary libraries and modules use bip39::Mnemonic; use bitcoin::bip32::{DerivationPath, Xpriv}; use bitcoin::consensus::deserialize; -use bitcoin::secp256k1::{PublicKey, Secp256k1, XOnlyPublicKey}; +use bitcoin::secp256k1::Secp256k1 as BtcSecp256k1; use bitcoin::{Network, PrivateKey, ScriptBuf, Transaction}; use bitcoin_hashes::hex::FromHex as _; -use silentpayments::SpVersion; + +use silentpayments::utils::{TEST_SCAN_PATH, TEST_SPEND_PATH}; // Import types from the silentpayments library use silentpayments::receiving::{Label, Receiver}; -use silentpayments::utils::receiving::{ - calculate_ecdh_shared_secret, calculate_tweak_data, get_pubkey_from_input, -}; -use silentpayments::utils::{OutPoint, TEST_SCAN_PATH, TEST_SPEND_PATH}; +use silentpayments::secp256k1::{Secp256k1, SecretKey, XOnlyPublicKey}; +use silentpayments::utils::OutPoint; +use silentpayments::utils::receiving::{PublicTweakData, get_pubkey_from_input}; +use silentpayments::{Network as SpNetwork, SpVersion, TransactionInputs, TransactionSharedSecret}; fn main() -> Result<(), Box> { - // Get the command-line arguments let args: Vec = env::args().collect(); - // Parse the mnemonic phrase from the first command-line argument let m = Mnemonic::from_str(args.get(1).unwrap())?; - - // Get the transaction hex string from the second command-line argument let tx_hex = args.get(2).unwrap(); // Parse the scriptpubkeys from the third command-line argument, split by whitespace and store // them in a vector let spks: Vec<&str> = args.get(3).unwrap().split_whitespace().collect(); - // Deserialize the transaction hex string into a Transaction object let tx: Transaction = deserialize(Vec::from_hex(tx_hex)?.as_slice())?; // Assert that the number of inputs in the transaction matches the number of scriptpubkeys @@ -44,59 +39,42 @@ fn main() -> Result<(), Box> { let scan_path = DerivationPath::from_str(TEST_SCAN_PATH).unwrap(); let spend_path = DerivationPath::from_str(TEST_SPEND_PATH).unwrap(); - // Create a new instance of Secp256k1 for cryptographic operations - let secp = Secp256k1::signing_only(); + let btc_secp = BtcSecp256k1::signing_only(); + let secp = Secp256k1::new(); - // Get the private keys for both scan and spend paths - let scan_privkey = master_key.derive_priv(&secp, &scan_path)?.private_key; - let spend_privkey = master_key.derive_priv(&secp, &spend_path)?.private_key; + let scan_privkey = master_key.derive_priv(&btc_secp, &scan_path)?.private_key; + let spend_privkey = master_key.derive_priv(&btc_secp, &spend_path)?.private_key; + let scan_sk = SecretKey::from_slice(&scan_privkey.secret_bytes())?; + let spend_sk = SecretKey::from_slice(&spend_privkey.secret_bytes())?; - // Create a change label for the wallet - let change_label = Label::new(scan_privkey, 0); + let change_label = Label::new(scan_sk, 0); - // Create a new Receiver object with the private and public keys, along with the change label let receiver = Receiver::new( SpVersion::ZERO, - scan_privkey.public_key(&secp), - spend_privkey.public_key(&secp), + scan_sk.public_key(&secp), + spend_sk.public_key(&secp), change_label, - silentpayments::Network::Testnet, + SpNetwork::Testnet, )?; - // Extract outpoints (previous transaction outputs) from the transaction inputs and store them - // in a vector - let outpoints: Vec = tx - .input - .iter() - .map(|i| { - let prevout = i.previous_output; - OutPoint::from_txid_and_vout(&prevout.txid.to_string(), prevout.vout).unwrap() - }) - .collect(); - - // Iterate through each input of the transaction and assert if it contains an eligible pubkey - let mut input_pubkeys: Vec = vec![]; + let mut inputs = TransactionInputs::new(); for (i, input) in tx.input.iter().enumerate() { + let prevout = &input.previous_output; + let outpoint = + OutPoint::from_txid_and_vout(&prevout.txid.to_string(), prevout.vout).unwrap(); let spk = ScriptBuf::from_hex(spks.get(i).unwrap())?; - if let Some(pubkey) = get_pubkey_from_input( + let pubkey = get_pubkey_from_input( input.script_sig.as_bytes(), &input.witness.to_vec(), spk.as_bytes(), - )? { - input_pubkeys.push(pubkey); - } + )?; + inputs.push(outpoint, spk.to_bytes(), pubkey); } - // Get the reference to a vector of public keys for further calculations - let pubkeys_ref: Vec<&PublicKey> = input_pubkeys.iter().collect(); - - // Calculate the tweak data based on the public keys and outpoints - let tweak_data = calculate_tweak_data(&pubkeys_ref, &outpoints)?; - - // Calculate the ECDH shared secret between the scan private key and the tweak data - let ecdh_shared_secret = calculate_ecdh_shared_secret(&tweak_data, &scan_privkey); + let tweak_data = PublicTweakData::new(&secp, &inputs)?; + let ecdh_shared_secret = + TransactionSharedSecret::new_from_public_tweak_data(&secp, &tweak_data, &scan_sk)?; - // Filter the transaction outputs that have a valid P2TR scriptpubkey let pubkeys_to_check: Vec<_> = tx .output .iter() @@ -118,7 +96,7 @@ fn main() -> Result<(), Box> { for (label, key_map) in my_outputs { println!("Found {} output(s) with label {:?}", key_map.len(), label); for (xonly, sk) in key_map { - let spending_key = spend_privkey.add_tweak(&sk).unwrap(); + let spending_key = spend_sk.add_tweak(&sk)?; let wif = PrivateKey::from_slice(&spending_key.secret_bytes(), Network::Signet) .unwrap() .to_wif(); diff --git a/silentpayments/src/lib.rs b/silentpayments/src/lib.rs index 698308b8..278814b9 100644 --- a/silentpayments/src/lib.rs +++ b/silentpayments/src/lib.rs @@ -14,14 +14,15 @@ pub mod utils; #[cfg(any(feature = "sending", feature = "receiving"))] pub use bitcoin_hashes; pub use secp256k1; -#[cfg(any(feature = "sending", feature = "receiving"))] -pub use utils::common::SharedSecret; -#[cfg(feature = "encode")] -pub use utils::common::SilentPaymentCode; -pub use utils::common::{Network, SilentPaymentKeyMaterial, SpVersion}; pub use crate::error::Error; +pub use utils::common::Network; +#[cfg(feature = "encode")] +pub use utils::common::SilentPaymentCode; #[cfg(any(feature = "sending", feature = "receiving"))] pub use utils::common::TransactionInputs; +#[cfg(any(feature = "sending", feature = "receiving"))] +pub use utils::common::TransactionSharedSecret; +pub use utils::common::{SilentPaymentKeyMaterial, SpVersion}; pub type Result = std::result::Result; diff --git a/silentpayments/src/receiving.rs b/silentpayments/src/receiving.rs index 4f7a66c2..c1b920dc 100644 --- a/silentpayments/src/receiving.rs +++ b/silentpayments/src/receiving.rs @@ -6,21 +6,26 @@ //! //! After creating a [`Receiver`] object, you can call //! [`scan_transaction`](Receiver::scan_transaction), to scan a specific transaction for outputs -//! belonging to this receiver. For this, you need to have calculated the `ecdh_shared_secret` -//! beforehand. To do so, you can use -//! [`calculate_ecdh_shared_secret`](`crate::utils::receiving::calculate_ecdh_shared_secret`) from -//! the `utils` module. +//! belonging to this receiver. //! -//! For a concrete example, have a look at the [test vectors](https://github.com/cygnet3/rust-silentpayments/blob/master/tests/vector_tests.rs). +//! This requires a [`TransactionSharedSecret`] for the transaction. Compute it from +//! [`PublicTweakData`](crate::utils::receiving::PublicTweakData) and the scan private key via +//! [`TransactionSharedSecret::new_from_public_tweak_data`]. +//! +//! For a concrete example, see the [test vectors](https://github.com/cygnet3/spdk/blob/master/silentpayments/tests/vector_tests.rs) +//! or the `find_output` example. use std::collections::{HashMap, HashSet}; use std::fmt; +use crate::{ + Error, Network, Result, SilentPaymentCode, SpVersion, + utils::{ + common::{TransactionSharedSecret, calculate_P_n, calculate_t_n}, + hash::calculate_label_hash, + }, +}; use secp256k1::{Parity, PublicKey, Scalar, Secp256k1, SecretKey, XOnlyPublicKey}; -use crate::utils::common::{SharedSecret, calculate_P_n, calculate_t_n}; -use crate::utils::hash::LabelHash; -use crate::{Error, Network, Result, SilentPaymentCode, SpVersion}; - /// A Silent payment receiving label. #[derive(Eq, PartialEq, Clone)] pub struct Label { @@ -30,7 +35,7 @@ pub struct Label { impl Label { pub fn new(b_scan: SecretKey, m: u32) -> Self { Self { - s: LabelHash::from_b_scan_and_m(b_scan, m).to_scalar(), + s: calculate_label_hash(b_scan, m), } } @@ -236,7 +241,7 @@ impl Receiver { /// malicious. pub fn scan_transaction( &self, - ecdh_shared_secret: &SharedSecret, + ecdh_shared_secret: &TransactionSharedSecret, pubkeys_to_check: &[XOnlyPublicKey], ) -> Result, HashMap>> { let secp = secp256k1::Secp256k1::new(); @@ -306,7 +311,7 @@ impl Receiver { /// malicious. pub fn generate_output_keys_from_shared_secret( &self, - ecdh_shared_secret: &SharedSecret, + ecdh_shared_secret: &TransactionSharedSecret, ) -> Result, XOnlyPublicKey>> { let t_0: SecretKey = calculate_t_n(ecdh_shared_secret, 0)?; let P_0: PublicKey = calculate_P_n(&self.spend_pubkey, t_0.into())?; diff --git a/silentpayments/src/sending.rs b/silentpayments/src/sending.rs index 3c083122..d378d0d6 100644 --- a/silentpayments/src/sending.rs +++ b/silentpayments/src/sending.rs @@ -14,7 +14,7 @@ use std::collections::HashMap; use secp256k1::{PublicKey, Secp256k1, XOnlyPublicKey}; -use crate::utils::common::{SharedSecret, SilentPaymentKeyMaterial, calculate_t_n}; +use crate::utils::common::{SilentPaymentKeyMaterial, TransactionSharedSecret, calculate_t_n}; use crate::utils::sending::{PartialSecret, calculate_ecdh_shared_secret}; use crate::{Error, Result}; @@ -55,9 +55,10 @@ where { let secp = Secp256k1::new(); - let mut silent_payment_groups: HashMap)> = HashMap::new(); + let mut silent_payment_groups: HashMap)> = + HashMap::new(); for recipient in recipients { - let key_material = recipient.into(); + let key_material: SilentPaymentKeyMaterial = recipient.into(); let recipient_scan_key = key_material.scan_key(); diff --git a/silentpayments/src/utils/common.rs b/silentpayments/src/utils/common.rs index 7b6c9fcc..49a39c95 100644 --- a/silentpayments/src/utils/common.rs +++ b/silentpayments/src/utils/common.rs @@ -6,18 +6,20 @@ use core::str::FromStr; use crate::Error; use crate::Result; #[cfg(any(feature = "sending", feature = "receiving"))] -use crate::utils::hash::SharedSecretHash; +use crate::utils::hash::calculate_shared_secret_hash; +#[cfg(feature = "receiving")] +use crate::utils::receiving::PublicTweakData; #[cfg(any(feature = "sending", feature = "receiving"))] use crate::utils::script::is_eligible; #[cfg(feature = "encode")] use bech32::Variant; #[cfg(feature = "encode")] use bech32::{FromBase32 as _, ToBase32 as _}; -#[cfg(any(feature = "sending", feature = "receiving"))] -use bitcoin_hashes::Hash as _; use secp256k1::PublicKey; use secp256k1::constants::PUBLIC_KEY_SIZE; #[cfg(any(feature = "sending", feature = "receiving"))] +use secp256k1::ecdh::shared_secret_point; +#[cfg(any(feature = "sending", feature = "receiving"))] use secp256k1::{Scalar, Secp256k1, SecretKey}; /// Struct representing an `OutPoint` type. @@ -108,7 +110,6 @@ impl TransactionInputs { pub fn new() -> Self { Self::default() } - pub fn with_capacity(capacity: usize) -> Self { Self { outpoints: Vec::with_capacity(capacity), @@ -176,25 +177,98 @@ impl TransactionInputs { } } +/// Compute `private_key * public_key` as a secp256k1 [`PublicKey`]. +/// +/// # Arguments +/// +/// * `public_key` - Either the recipient scan public key (sender) or the sum of all eligible inputs public keys (recipient). +/// * `private_key` - Either one or all private keys used in the inputs of the transaction (sender) or the private scan key (recipient). +/// +/// # Returns +/// +/// The shared secret as a [`PublicKey`]. +/// +/// # Errors +/// +/// This function will error if: +/// +/// * The elliptic curve computation results in an invalid public key. +/// +/// Uses `shared_secret_point` for constant-time scalar multiplication. +#[cfg(any(feature = "sending", feature = "receiving"))] +pub(crate) fn ecdh_multiply(public_key: &PublicKey, private_key: &SecretKey) -> Result { + let mut ss_bytes = [0u8; 65]; + ss_bytes[0] = 0x04; + ss_bytes[1..].copy_from_slice(&shared_secret_point(public_key, private_key)); + Ok(PublicKey::from_slice(&ss_bytes)?) +} + +/// Represents the shared secret, one for each scan key in the outputs, which is either obtained from +/// * sum of all eligible inputs private keys multiplied with the input hash, multiplied with the scan public key, or +/// * sum of all eligible inputs public keys multiplied with the input hash, multiplied with the scan private key. +/// +/// Since sender and recipient are supposed to end up with the same shared secret, this is the final type used for both. #[cfg(any(feature = "sending", feature = "receiving"))] #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)] -pub struct SharedSecret(pub(crate) PublicKey); +pub struct TransactionSharedSecret { + ecdh_shared_secret: PublicKey, + recipient_scan_key: PublicKey, +} -impl From for SharedSecret { - fn from(value: PublicKey) -> Self { - Self(value) +#[expect(clippy::missing_const_for_fn)] +impl TransactionSharedSecret { + #[cfg(feature = "sending")] + pub(crate) fn from_sender_ecdh( + ecdh_shared_secret: PublicKey, + recipient_scan_key: PublicKey, + ) -> Self { + Self { + ecdh_shared_secret, + recipient_scan_key, + } + } + + /// Calculate the shared secret of a transaction as a receiver. + /// + /// # Arguments + /// + /// * `tweak_data` - The tweak data of the transaction, see [`PublicTweakData::new`]. + /// * `recipient_scan_key` - The scan private key used by the wallet. + /// + /// # Returns + /// + /// This function returns the shared secret of this transaction. This shared secret can be used to scan the transaction of outputs that are for the current user. See [`Receiver::scan_transaction`](crate::receiving::Receiver::scan_transaction). + #[cfg(feature = "receiving")] + pub fn new_from_public_tweak_data( + secp: &Secp256k1, + tweak_data: &PublicTweakData, + recipient_scan_key: &SecretKey, + ) -> Result { + Ok(Self { + ecdh_shared_secret: ecdh_multiply(tweak_data.as_inner(), recipient_scan_key)?, + recipient_scan_key: PublicKey::from_secret_key(secp, recipient_scan_key), + }) + } + + pub fn as_ecdh_shared_secret(&self) -> &PublicKey { + &self.ecdh_shared_secret + } + + pub fn into_ecdh_shared_secret(self) -> PublicKey { + self.ecdh_shared_secret } -} -impl From for PublicKey { - fn from(value: SharedSecret) -> Self { - value.0 + pub fn as_recipient_scan_key(&self) -> &PublicKey { + &self.recipient_scan_key } } #[cfg(any(feature = "sending", feature = "receiving"))] -pub(crate) fn calculate_t_n(ecdh_shared_secret: &SharedSecret, k: u32) -> Result { - let hash = SharedSecretHash::from_ecdh_and_k(ecdh_shared_secret, k).to_byte_array(); +pub(crate) fn calculate_t_n( + ecdh_shared_secret: &TransactionSharedSecret, + k: u32, +) -> Result { + let hash = calculate_shared_secret_hash(ecdh_shared_secret, k); let sk = SecretKey::from_slice(&hash)?; Ok(sk) diff --git a/silentpayments/src/utils/hash.rs b/silentpayments/src/utils/hash.rs index 17461e07..cf29141f 100644 --- a/silentpayments/src/utils/hash.rs +++ b/silentpayments/src/utils/hash.rs @@ -1,5 +1,5 @@ -use crate::utils::common::{OutPoint, SharedSecret}; -use bitcoin_hashes::{Hash, HashEngine, sha256t_hash_newtype}; +use crate::utils::common::{OutPoint, TransactionSharedSecret}; +use bitcoin_hashes::{Hash as _, HashEngine as _, sha256t_hash_newtype}; use secp256k1::{PublicKey, Scalar, SecretKey}; sha256t_hash_newtype! { @@ -11,13 +11,13 @@ sha256t_hash_newtype! { #[hash_newtype(forward)] struct InputsHash(_); - pub(crate) struct LabelTag = hash_str("BIP0352/Label"); + struct LabelTag = hash_str("BIP0352/Label"); /// BIP0352-tagged hash with tag \"Label\". /// /// This is used for computing the label tweak. #[hash_newtype(forward)] - pub(crate) struct LabelHash(_); + struct LabelHash(_); pub(crate) struct SharedSecretTag = hash_str("BIP0352/SharedSecret"); @@ -57,9 +57,9 @@ impl LabelHash { } impl SharedSecretHash { - pub(crate) fn from_ecdh_and_k(ecdh: &SharedSecret, k: u32) -> Self { + pub(crate) fn from_ecdh_and_k(ecdh: &TransactionSharedSecret, k: u32) -> Self { let mut eng = Self::engine(); - eng.input(&ecdh.0.serialize()); + eng.input(&ecdh.as_ecdh_shared_secret().serialize()); eng.input(&k.to_be_bytes()); Self::from_engine(eng) } @@ -68,3 +68,11 @@ impl SharedSecretHash { pub(crate) fn calculate_input_hash(smaller_outpoint: &OutPoint, A_sum: PublicKey) -> Scalar { InputsHash::from_outpoint_and_A_sum(smaller_outpoint, A_sum).to_scalar() } + +pub(crate) fn calculate_label_hash(b_scan: SecretKey, m: u32) -> Scalar { + LabelHash::from_b_scan_and_m(b_scan, m).to_scalar() +} + +pub(crate) fn calculate_shared_secret_hash(ecdh: &TransactionSharedSecret, k: u32) -> [u8; 32] { + SharedSecretHash::from_ecdh_and_k(ecdh, k).to_byte_array() +} diff --git a/silentpayments/src/utils/receiving.rs b/silentpayments/src/utils/receiving.rs index c8355132..4d20f094 100644 --- a/silentpayments/src/utils/receiving.rs +++ b/silentpayments/src/utils/receiving.rs @@ -1,15 +1,14 @@ //! Receiving utility functions. use bitcoin_hashes::{Hash as _, hash160}; use secp256k1::Parity::Even; -use secp256k1::ecdh::shared_secret_point; -use secp256k1::{PublicKey, SecretKey, XOnlyPublicKey}; +use secp256k1::{PublicKey, Secp256k1, Verification, XOnlyPublicKey}; use super::hash::calculate_input_hash; use super::{ COMPRESSED_PUBKEY_SIZE, NUMS_H, OP_PUSHBYTES_1, OP_PUSHBYTES_75, OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4, TAPROOT_ANNEX_PREFIX, }; -use crate::utils::common::{NonEmptyArray, OutPoint, SharedSecret}; +use crate::utils::common::TransactionInputs; pub use crate::utils::script::{is_eligible, is_p2tr}; use crate::utils::script::{is_p2pkh, is_p2sh, is_p2wpkh}; use crate::utils::{OP_1, OP_PUSHBYTES_32}; @@ -62,61 +61,46 @@ fn witness_compressed_pubkey(witness_last: &[u8], expected_hash: &[u8]) -> Optio /// Public tweak data for a transaction: `input_hash * sum(eligible input pubkeys)`. /// -/// This is useful in combination with the [`calculate_ecdh_shared_secret`] function, but can also -/// be used by indexing servers that don't have access to the recipient scan key. -/// -/// # Arguments -/// -/// * `input_pub_keys` - The list of public keys that are used as input for this transaction. Only -/// the public keys for inputs that are silent payment eligible should be given. -/// * `outpoints_data` - All prevout outpoints used as input for this transaction. Note that the -/// txid is given in String format, which is displayed in reverse order from the inner byte array. -/// -/// # Returns -/// -/// This function returns the tweak data for this transaction. The tweak data is an intermediary -/// result that can be used to calculate the final shared secret. -/// -/// # Errors -/// -/// This function will error if: -/// -/// * The input public keys array is of length zero, or the summing results in an invalid key. -/// * The `outpoints_data` is of length zero, or invalid. -/// * Elliptic curve computation results in an invalid public key. -pub fn calculate_tweak_data( - input_pub_keys: &[&PublicKey], - outpoints_data: &[OutPoint], -) -> Result { - let secp = secp256k1::Secp256k1::verification_only(); - let A_sum = PublicKey::combine_keys(input_pub_keys)?; - - let outpoints = NonEmptyArray::new(outpoints_data)?; - let input_hash = calculate_input_hash(outpoints.min(), A_sum); +/// Indexing servers can publish this value so recipients can derive a +/// [`TransactionSharedSecret`](crate::TransactionSharedSecret) locally without revealing their scan +/// private key. +pub struct PublicTweakData(PublicKey); - Ok(A_sum.mul_tweak(&secp, &input_hash)?) -} - -/// Calculate the shared secret of a transaction. -/// -/// # Arguments -/// -/// * `tweak_data` - The tweak data of the transaction, see `calculate_tweak_data`. -/// * `b_scan` - The scan private key used by the wallet. -/// -/// # Returns -/// -/// This function returns the shared secret of this transaction. This shared secret can be used to -/// scan the transaction of outputs that are for the current user. See -/// [`Receiver::scan_transaction`](crate::receiving::Receiver::scan_transaction). -pub fn calculate_ecdh_shared_secret(tweak_data: &PublicKey, b_scan: &SecretKey) -> SharedSecret { - let mut ss_bytes = [0u8; 65]; - ss_bytes[0] = 0x04; +#[expect(clippy::missing_const_for_fn)] +impl PublicTweakData { + /// Construct tweak data from a value obtained from a trusted external source. + /// + /// Prefer [`Self::new`] when computing from chain data directly. + pub fn new_unchecked(tweak_data: PublicKey) -> Self { + Self(tweak_data) + } - // Using `shared_secret_point` to ensure the multiplication is constant time - ss_bytes[1..].copy_from_slice(&shared_secret_point(tweak_data, b_scan)); + /// Calculate the tweak data of a transaction: `input_hash * sum(eligible input pubkeys)`. + /// + /// Uses the same eligible-input rules as sender-side shared secret derivation. Combine with + /// [`TransactionSharedSecret::new_from_public_tweak_data`](crate::TransactionSharedSecret::new_from_public_tweak_data) + /// to obtain the shared secret used by [`Receiver::scan_transaction`](crate::receiving::Receiver::scan_transaction). + /// + /// # Arguments + /// + /// * `inputs` - Parallel outpoints, script pubkeys and extracted pubkeys for every vin. + /// + /// # Errors + /// + /// This function will error if: + /// + /// * `inputs` is empty. + /// * No eligible input pubkeys could be extracted. + /// * Elliptic curve computation results in an invalid public key. + pub fn new(secp: &Secp256k1, inputs: &TransactionInputs) -> Result { + let summed_pubkeys = inputs.eligible_pubkeys_sum()?; + let input_hash = calculate_input_hash(inputs.min_outpoint(), summed_pubkeys); + Ok(Self(summed_pubkeys.mul_tweak(secp, &input_hash)?)) + } - SharedSecret(PublicKey::from_slice(&ss_bytes).expect("guaranteed to be a point on the curve")) + pub fn as_inner(&self) -> &PublicKey { + &self.0 + } } /// Get the public keys from a set of input data. diff --git a/silentpayments/src/utils/sending.rs b/silentpayments/src/utils/sending.rs index e24affb5..49361e05 100644 --- a/silentpayments/src/utils/sending.rs +++ b/silentpayments/src/utils/sending.rs @@ -1,12 +1,37 @@ //! Sending utility functions. use secp256k1::constants::SECRET_KEY_SIZE; -use secp256k1::ecdh::shared_secret_point; -use secp256k1::{PublicKey, Secp256k1, SecretKey}; +use secp256k1::{PublicKey, Secp256k1, SecretKey, Signing}; use super::hash::calculate_input_hash; -use crate::utils::common::{NonEmptyArray, OutPoint, SharedSecret}; +use crate::utils::common::{NonEmptyArray, OutPoint, TransactionSharedSecret, ecdh_multiply}; use crate::{Error, Result}; +/// Guarantees that the secret key produces an even x-only public key when the spent output is +/// taproot, by negating the secret key if necessary. +#[derive(Debug, Clone)] +pub struct NormalizedSecretKey(SecretKey); + +#[expect(clippy::missing_const_for_fn)] +impl NormalizedSecretKey { + pub fn new(secp: &Secp256k1, secret_key: SecretKey, is_taproot: bool) -> Self { + let (_, parity) = secret_key.x_only_public_key(secp); + + if is_taproot && parity == secp256k1::Parity::Odd { + return Self(secret_key.negate()); + } + + Self(secret_key) + } + + pub fn as_inner(&self) -> &SecretKey { + &self.0 + } + + pub fn into_inner(self) -> SecretKey { + self.0 + } +} + /// Represents the sum of all eligible input private keys of a transaction, multiplied with the /// input hash. #[derive(Clone, Copy, Debug)] @@ -91,14 +116,11 @@ pub fn calculate_partial_secret( pub fn calculate_ecdh_shared_secret( B_scan: &PublicKey, partial_secret: &PartialSecret, -) -> SharedSecret { - let mut ss_bytes = [0u8; 65]; - ss_bytes[0] = 0x04; - - // Using `shared_secret_point` to ensure the multiplication is constant time - ss_bytes[1..].copy_from_slice(&shared_secret_point(B_scan, &partial_secret.0)); - - SharedSecret(PublicKey::from_slice(&ss_bytes).expect("guaranteed to be a point on the curve")) +) -> TransactionSharedSecret { + TransactionSharedSecret::from_sender_ecdh( + ecdh_multiply(B_scan, &partial_secret.0).expect("guaranteed to be a point on the curve"), + *B_scan, + ) } fn get_a_sum_secret_keys(input: &[(SecretKey, bool)]) -> Result { @@ -106,25 +128,18 @@ fn get_a_sum_secret_keys(input: &[(SecretKey, bool)]) -> Result { return Err(Error::GenericError("No input provided".to_owned())); } - let secp = secp256k1::Secp256k1::new(); - - let mut negated_keys: Vec = vec![]; - - for (key, is_taproot) in input { - let (_, parity) = key.x_only_public_key(&secp); - - if *is_taproot && parity == secp256k1::Parity::Odd { - negated_keys.push(key.negate()); - } else { - negated_keys.push(*key); - } - } - - let (head, tail) = negated_keys.split_first().expect("input is non-empty"); + let secp = Secp256k1::new(); - let result: SecretKey = tail + let normalized: Vec = input .iter() - .try_fold(*head, |acc, &item| acc.add_tweak(&item.into()))?; + .map(|(key, is_taproot)| NormalizedSecretKey::new(&secp, *key, *is_taproot)) + .collect(); + + let (head, tail) = normalized.split_first().expect("input is non-empty"); - Ok(result) + tail.iter() + .try_fold(*head.as_inner(), |acc, item| { + acc.add_tweak(&(*item.as_inner()).into()) + }) + .map_err(Error::from) } diff --git a/silentpayments/tests/vector_tests.rs b/silentpayments/tests/vector_tests.rs index d053a61b..5709f607 100644 --- a/silentpayments/tests/vector_tests.rs +++ b/silentpayments/tests/vector_tests.rs @@ -5,15 +5,13 @@ mod tests { use std::collections::HashSet; use bitcoin::hashes::Hash as _; - use secp256k1::{PublicKey, Scalar, Secp256k1}; + use secp256k1::{Scalar, Secp256k1}; use silentpayments::receiving::{Label, Receiver}; use silentpayments::sending::generate_recipient_pubkeys; use silentpayments::utils::OutPoint; - use silentpayments::utils::receiving::{ - calculate_ecdh_shared_secret, calculate_tweak_data, get_pubkey_from_input, is_p2tr, - }; + use silentpayments::utils::receiving::{PublicTweakData, get_pubkey_from_input, is_p2tr}; use silentpayments::utils::sending::calculate_partial_secret; - use silentpayments::{Network, SilentPaymentCode}; + use silentpayments::{Network, SilentPaymentCode, TransactionInputs, TransactionSharedSecret}; use crate::common::structs::TestData; use crate::common::utils::{self, verify_and_calculate_signatures}; @@ -104,29 +102,27 @@ mod tests { let outputs_to_check = given.outputs; - let outpoints: Vec = given - .vin - .iter() - .map(|vin| OutPoint::from_txid_bytes_and_vout(vin.txid.to_byte_array(), vin.vout)) - .collect(); - let mut input_pub_keys = Vec::new(); + // Keep every vin. The input hash uses the smallest outpoint of the whole + // transaction, including inputs that are not silent-payment eligible. + let mut inputs = TransactionInputs::with_capacity(given.vin.len()); for input in given.vin { - let script_sig = input.scriptSig.as_bytes(); - let txinwitness = input.txinwitness.to_vec(); - let script_pub_key = input.prevout.scriptPubKey.hex.as_bytes(); - - match get_pubkey_from_input(script_sig, &txinwitness, script_pub_key) { - Ok(Some(pubkey)) => input_pub_keys.push(pubkey), - Ok(None) => (), + let outpoint = + OutPoint::from_txid_bytes_and_vout(input.txid.to_byte_array(), input.vout); + let script_pub_key = input.prevout.scriptPubKey.hex.as_bytes().to_vec(); + let pubkey = match get_pubkey_from_input( + input.scriptSig.as_bytes(), + &input.txinwitness.to_vec(), + &script_pub_key, + ) { + Ok(pubkey) => pubkey, Err(e) => panic!("Problem parsing the input: {e:?}"), - } + }; + inputs.push(outpoint, script_pub_key, pubkey); } - if input_pub_keys.is_empty() { + if inputs.input_pubkeys().iter().all(Option::is_none) { continue; } - let input_pub_keys: Vec<&PublicKey> = input_pub_keys.iter().collect(); - for label_int in &given.labels { let label = Label::new(b_scan, *label_int); sp_receiver.add_label(label).unwrap(); @@ -152,8 +148,10 @@ mod tests { // to the expected codes assert_eq!(receiving_codes, expected_codes); - let tweak_data = calculate_tweak_data(&input_pub_keys, &outpoints).unwrap(); - let ecdh_shared_secret = calculate_ecdh_shared_secret(&tweak_data, &b_scan); + let tweak_data = PublicTweakData::new(&secp, &inputs).unwrap(); + let ecdh_shared_secret = + TransactionSharedSecret::new_from_public_tweak_data(&secp, &tweak_data, &b_scan) + .unwrap(); let scanned_outputs_received = sp_receiver .scan_transaction(&ecdh_shared_secret, &outputs_to_check) diff --git a/spdk-wallet/Cargo.toml b/spdk-wallet/Cargo.toml index c578f3eb..b68d3267 100644 --- a/spdk-wallet/Cargo.toml +++ b/spdk-wallet/Cargo.toml @@ -21,6 +21,7 @@ silentpayments.workspace = true log.workspace = true bdk_coin_select.workspace = true bip321.workspace = true +rayon = { workspace = true, optional = true } [dev-dependencies] tokio.workspace = true @@ -29,7 +30,7 @@ serde_json.workspace = true [features] -default = ["backend-blindbit-v1", "local-scanner"] +default = ["backend-blindbit-v1", "local-scanner", "rayon"] [lints] workspace = true diff --git a/spdk-wallet/src/client/client.rs b/spdk-wallet/src/client/client.rs index b7ddf858..aa1701d7 100644 --- a/spdk-wallet/src/client/client.rs +++ b/spdk-wallet/src/client/client.rs @@ -1,11 +1,13 @@ +use std::collections::HashMap; use std::io::Write as _; use anyhow::{Error, Result}; -use bitcoin::Network; -use bitcoin::secp256k1::{Secp256k1, SecretKey}; +use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; +use bitcoin::{Network, XOnlyPublicKey}; use silentpayments::bitcoin_hashes::{Hash as _, sha256}; use silentpayments::receiving::{Label, Receiver}; -use silentpayments::{Network as SpNetwork, SilentPaymentCode, SpVersion}; +use silentpayments::utils::receiving::PublicTweakData; +use silentpayments::{Network as SpNetwork, SilentPaymentCode, SpVersion, TransactionSharedSecret}; use super::SpendKey; @@ -76,6 +78,50 @@ impl SpClient { } } + pub fn output_key_to_secret_map( + &self, + tweak_data_vec: Vec, + ) -> Result> { + // if using rayon feature, import the preludes + #[cfg(feature = "rayon")] + use rayon::prelude::*; + + let b_scan = &self.scan_key(); + let secp = Secp256k1::signing_only(); + + // parallel iterator using rayon + #[cfg(feature = "rayon")] + let tweak_data_iterator = tweak_data_vec.into_par_iter(); + + // regular iterator + #[cfg(not(feature = "rayon"))] + let tweak_data_iterator = tweak_data_vec.into_iter(); + + let items: Result> = tweak_data_iterator + .map(|tweak| { + let public_tweak = PublicTweakData::new_unchecked(tweak); + let secret = TransactionSharedSecret::new_from_public_tweak_data( + &secp, + &public_tweak, + b_scan, + )?; + let output_keys = self + .sp_receiver + .generate_output_keys_from_shared_secret(&secret)?; + + Ok((secret, output_keys.into_values())) + }) + .collect(); + + let mut res = HashMap::new(); + for (secret, spks) in items? { + for spk in spks { + res.insert(spk, secret); + } + } + Ok(res) + } + pub fn client_fingerprint(&self) -> Result<[u8; 8]> { let sp_code: SilentPaymentCode = self.receiving_code(); let scan_pk = sp_code.scan_key(); From 44ad8520bdf089064b32a45a6796780bf8ca9fa0 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Thu, 18 Jun 2026 11:04:17 +0200 Subject: [PATCH 04/13] feat(silentpayments): add BIP-374 DLEQ ECDH share types Add PartialSenderEcdhShare and GlobalSenderEcdhShare with rust-dleq proofs, plus TransactionSharedSecret constructors from a global share or aggregated partial shares. Gate sending on dleq-standalone or dleq-native (default: dleq-standalone). Retain PartialSecret alongside the new path. Also bump workspace bitcoin_hashes to 0.14 and silentpayments' bip39 dev-dependency to 2.2. --- Cargo.toml | 3 +- silentpayments/Cargo.toml | 9 +- silentpayments/src/error.rs | 10 ++ silentpayments/src/lib.rs | 19 ++- silentpayments/src/utils.rs | 5 +- silentpayments/src/utils/common.rs | 135 ++++++++++++++- silentpayments/src/utils/sending.rs | 252 +++++++++++++++++++++++++++- 7 files changed, 421 insertions(+), 12 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index b0ea293a..901d6107 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,7 +23,7 @@ serde = { version = "1.0.188", features = ["derive"] } serde_json = "1.0.107" bip321 = { git = "https://gitlab.com/Sosthene00/bark.git", rev = "83ab79264159869503b16fa475e0ed61ffa33174", default-features = false } bitcoin = { version = "0.32.8", features = ["serde", "rand", "base64"] } -bitcoin_hashes = "0.13.0" +bitcoin_hashes = "0.14" rayon = "1.10.0" tokio = { version = "1", features = ["macros", "rt-multi-thread"] } futures = "0.3" @@ -36,6 +36,7 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } +rust-dleq = { git = "https://github.com/Sosthene00/rust-dleq.git", rev = "097644a14d87c454e9bd9895de2e60992ff1ba93", default-features = false } secp256k1 = { version = "0.29.0" } [workspace.package] diff --git a/silentpayments/Cargo.toml b/silentpayments/Cargo.toml index 79364442..61912f13 100644 --- a/silentpayments/Cargo.toml +++ b/silentpayments/Cargo.toml @@ -16,19 +16,22 @@ name = "silentpayments" crate-type = ["lib"] [features] -default = ["encode", "sending", "receiving"] +default = ["encode", "sending", "receiving", "dleq-standalone"] encode = ["dep:bech32"] sending = ["dep:bitcoin_hashes", "dep:hex", "encode"] receiving = ["dep:bitcoin_hashes", "dep:hex", "encode"] +dleq-standalone = ["sending", "dep:rust-dleq", "rust-dleq/standalone"] +dleq-native = ["sending", "dep:rust-dleq", "rust-dleq/native"] [dependencies] secp256k1.workspace = true hex = { workspace = true, optional = true } bech32 = { workspace = true, optional = true } bitcoin_hashes = { workspace = true, optional = true } +rust-dleq = { workspace = true, optional = true } [dev-dependencies] -rust-bip39 = { version = "1.0.0", features = ["rand"] } +bip39 = { version = "2.2", features = ["rand"] } bitcoin = { version = "0.32.8", features = ["serde"] } serde.workspace = true serde_json = "1.0" @@ -47,4 +50,4 @@ required-features = ["receiving"] [[test]] name = "vector_tests" -required-features = ["receiving", "sending"] +required-features = ["receiving", "sending", "dleq-standalone"] diff --git a/silentpayments/src/error.rs b/silentpayments/src/error.rs index 701bffd5..b85f8ddb 100644 --- a/silentpayments/src/error.rs +++ b/silentpayments/src/error.rs @@ -64,3 +64,13 @@ impl From for Error { Self::IOError(e) } } + +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] +impl From for Error { + fn from(e: rust_dleq::DleqError) -> Self { + Self::GenericError(e.to_string()) + } +} diff --git a/silentpayments/src/lib.rs b/silentpayments/src/lib.rs index 278814b9..ae9667aa 100644 --- a/silentpayments/src/lib.rs +++ b/silentpayments/src/lib.rs @@ -1,5 +1,14 @@ #![doc = include_str!("../README.md")] #![allow(dead_code, non_snake_case)] + +#[cfg(all( + feature = "sending", + not(any(feature = "dleq-standalone", feature = "dleq-native")) +))] +compile_error!( + "The `sending` feature requires either `dleq-standalone` or `dleq-native` to select a DLEQ backend." +); + mod error; #[cfg(doc)] @@ -7,7 +16,10 @@ use std::str::FromStr; #[cfg(feature = "receiving")] pub mod receiving; -#[cfg(feature = "sending")] +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] pub mod sending; pub mod utils; @@ -16,6 +28,11 @@ pub use bitcoin_hashes; pub use secp256k1; pub use crate::error::Error; +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] +pub use rust_dleq::DleqProof; pub use utils::common::Network; #[cfg(feature = "encode")] pub use utils::common::SilentPaymentCode; diff --git a/silentpayments/src/utils.rs b/silentpayments/src/utils.rs index 15477af5..10910e9e 100644 --- a/silentpayments/src/utils.rs +++ b/silentpayments/src/utils.rs @@ -8,7 +8,10 @@ pub(crate) mod hash; pub mod receiving; #[cfg(any(feature = "sending", feature = "receiving"))] pub(crate) mod script; -#[cfg(feature = "sending")] +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] pub mod sending; pub(crate) mod common; diff --git a/silentpayments/src/utils/common.rs b/silentpayments/src/utils/common.rs index 49a39c95..dffa21f9 100644 --- a/silentpayments/src/utils/common.rs +++ b/silentpayments/src/utils/common.rs @@ -1,20 +1,30 @@ #[cfg(feature = "encode")] -use core::fmt; -#[cfg(feature = "encode")] use core::str::FromStr; use crate::Error; use crate::Result; +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] +use crate::utils::hash::calculate_input_hash; #[cfg(any(feature = "sending", feature = "receiving"))] use crate::utils::hash::calculate_shared_secret_hash; #[cfg(feature = "receiving")] use crate::utils::receiving::PublicTweakData; #[cfg(any(feature = "sending", feature = "receiving"))] use crate::utils::script::is_eligible; +#[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") +))] +use crate::utils::sending::{GlobalSenderEcdhShare, PartialSenderEcdhShare}; #[cfg(feature = "encode")] use bech32::Variant; #[cfg(feature = "encode")] use bech32::{FromBase32 as _, ToBase32 as _}; +#[cfg(feature = "encode")] +use core::fmt; use secp256k1::PublicKey; use secp256k1::constants::PUBLIC_KEY_SIZE; #[cfg(any(feature = "sending", feature = "receiving"))] @@ -171,6 +181,19 @@ impl TransactionInputs { Ok(eligible) } + #[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") + ))] + pub fn eligible_vins(&self) -> Vec { + self.script_pubkeys + .iter() + .zip(&self.input_pubkeys) + .enumerate() + .filter_map(|(vin, (spk, pk))| (pk.is_some() && is_eligible(spk)).then_some(vin)) + .collect() + } + pub(crate) fn eligible_pubkeys_sum(&self) -> Result { let eligible_pubkeys = self.eligible_pubkeys()?; Ok(PublicKey::combine_keys(&eligible_pubkeys)?) @@ -228,6 +251,103 @@ impl TransactionSharedSecret { } } + /// Create a shared secret from a finalized global ECDH share (sender path). + #[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") + ))] + pub fn new_from_global_share( + secp: &Secp256k1, + global_share: &GlobalSenderEcdhShare, + inputs: &TransactionInputs, + ) -> Result { + let eligible_pubkeys = inputs.eligible_pubkeys()?; + global_share.verify_dleq_proof(secp, NonEmptyArray::new(&eligible_pubkeys)?)?; + let input_hash = + calculate_input_hash(inputs.min_outpoint(), inputs.eligible_pubkeys_sum()?); + let tweaked_share = global_share + .as_ecdh_shared_secret() + .mul_tweak(secp, &input_hash)?; + Ok(Self { + ecdh_shared_secret: tweaked_share, + recipient_scan_key: *global_share.recipient_scan_key(), + }) + } + + /// Create a shared secret by summing hashed partial ECDH shares (multi-signer sender path). + /// + /// Every SP-eligible input in the transaction (i.e. every vin where the script type is + /// eligible and a pubkey was extracted) must have a corresponding partial share. Missing + /// or extra shares are rejected so the `input_hash` is computed over the same pubkey set + /// as the receiver uses. + #[cfg(all( + feature = "sending", + any(feature = "dleq-standalone", feature = "dleq-native") + ))] + pub fn new_from_partial_shares( + secp: &Secp256k1, + recipient_scan_key: PublicKey, + partial_shares: NonEmptyArray, + inputs: &TransactionInputs, + ) -> Result { + let eligible_vins = inputs.eligible_vins(); + + let mut partial_vins = Vec::with_capacity(partial_shares.as_inner().len()); + for share in partial_shares.as_inner() { + if *share.recipient_scan_key() != recipient_scan_key { + return Err(Error::GenericError(format!( + "Unexpected recipient scan key for share vin {}: {}", + share.input_vin(), + share.recipient_scan_key(), + ))); + } + let vin = share.input_vin(); + if partial_vins.contains(&vin) { + return Err(Error::GenericError(format!("Input vin {vin} already seen"))); + } + partial_vins.push(vin); + } + + partial_vins.sort_unstable(); + if partial_vins != eligible_vins { + let missing: Vec = eligible_vins + .iter() + .copied() + .filter(|vin| partial_vins.binary_search(vin).is_err()) + .collect(); + let unexpected: Vec = partial_vins + .into_iter() + .filter(|vin| eligible_vins.binary_search(vin).is_err()) + .collect(); + return Err(Error::GenericError(format!( + "Partial share coverage mismatch. \ + Missing shares for eligible vins: {missing:?}. \ + Shares for non-eligible vins: {unexpected:?}" + ))); + } + + let mut shares_to_sum: Vec<&PublicKey> = + Vec::with_capacity(partial_shares.as_inner().len()); + for share in partial_shares.as_inner() { + let vin = share.input_vin(); + let pubkey = inputs + .input_pubkey(vin) + .expect("partial vin is eligible and has pubkey"); + share.verify_dleq_proof(secp, pubkey)?; + shares_to_sum.push(share.as_ecdh_shared_secret()); + } + + let input_hash = + calculate_input_hash(inputs.min_outpoint(), inputs.eligible_pubkeys_sum()?); + let tweaked_share = + PublicKey::combine_keys(&shares_to_sum)?.mul_tweak(secp, &input_hash)?; + + Ok(Self { + ecdh_shared_secret: tweaked_share, + recipient_scan_key, + }) + } + /// Calculate the shared secret of a transaction as a receiver. /// /// # Arguments @@ -603,7 +723,16 @@ impl From for String { } } -pub(crate) struct NonEmptyArray<'a, T>(&'a [T]); +#[derive(Debug)] +pub struct NonEmptyArray<'a, T>(&'a [T]); + +impl Clone for NonEmptyArray<'_, T> { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for NonEmptyArray<'_, T> {} impl<'a, T> NonEmptyArray<'a, T> { pub const fn new(arr: &'a [T]) -> crate::Result { diff --git a/silentpayments/src/utils/sending.rs b/silentpayments/src/utils/sending.rs index 49361e05..a2e48da9 100644 --- a/silentpayments/src/utils/sending.rs +++ b/silentpayments/src/utils/sending.rs @@ -1,10 +1,24 @@ //! Sending utility functions. -use secp256k1::constants::SECRET_KEY_SIZE; -use secp256k1::{PublicKey, Secp256k1, SecretKey, Signing}; +//! +//! The typical flow for a single signer with DLEQ proofs is: +//! +//! 1. Normalize input private keys with [`NormalizedSecretKey`]. +//! 2. Create a [`GlobalSenderEcdhShare`] (single spender) or [`PartialSenderEcdhShare`]s (per input - collaborative transaction). +//! 3. Verify BIP374 DLEQ proofs with [`PartialSenderEcdhShare::verify_dleq_proof`] / +//! [`GlobalSenderEcdhShare::verify_dleq_proof`]. +//! 4. Convert to a [`TransactionSharedSecret`](crate::TransactionSharedSecret), which applies the +//! BIP352 input hash. +//! +//! The legacy [`calculate_partial_secret`] / [`PartialSecret`] API remains available for callers +//! that do not need DLEQ proofs. -use super::hash::calculate_input_hash; use crate::utils::common::{NonEmptyArray, OutPoint, TransactionSharedSecret, ecdh_multiply}; use crate::{Error, Result}; +use rust_dleq::{DleqProof, generate_dleq_proof, verify_dleq_proof}; +use secp256k1::constants::SECRET_KEY_SIZE; +use secp256k1::{PublicKey, Secp256k1, SecretKey, Signing, Verification}; + +use super::hash::calculate_input_hash; /// Guarantees that the secret key produces an even x-only public key when the spent output is /// taproot, by negating the secret key if necessary. @@ -32,6 +46,17 @@ impl NormalizedSecretKey { } } +impl NonEmptyArray<'_, NormalizedSecretKey> { + pub fn sum_keys(&self) -> Result { + let (head, tail) = self.as_inner().split_first().expect("Is non-empty"); + tail.iter() + .try_fold(*head.as_inner(), |acc, item| { + acc.add_tweak(&(*item.as_inner()).into()) + }) + .map_err(Error::from) + } +} + /// Represents the sum of all eligible input private keys of a transaction, multiplied with the /// input hash. #[derive(Clone, Copy, Debug)] @@ -143,3 +168,224 @@ fn get_a_sum_secret_keys(input: &[(SecretKey, bool)]) -> Result { }) .map_err(Error::from) } + +/// ECDH share for a single eligible input: `a_i * B_scan` (before input hash). +/// +/// Used in multi-signer flows where each party contributes one input. +/// Combine hashed partial shares into a [`TransactionSharedSecret`](crate::TransactionSharedSecret) via +/// [`TransactionSharedSecret::new_from_partial_shares`](crate::TransactionSharedSecret::new_from_partial_shares). +pub struct PartialSenderEcdhShare { + recipient_scan_key: PublicKey, + input_vin: usize, + ecdh_shared_secret: PublicKey, + dleq_proof: DleqProof, +} + +#[expect(clippy::missing_const_for_fn)] +impl PartialSenderEcdhShare { + pub fn new( + secp: &Secp256k1, + recipient_scan_key: PublicKey, + input_vin: usize, + private_key: &NormalizedSecretKey, + aux_rand: &[u8; 32], + ) -> Result { + let shared_secret = ecdh_multiply(&recipient_scan_key, private_key.as_inner())?; + let proof = generate_dleq_proof( + secp, + private_key.as_inner(), + &recipient_scan_key, + aux_rand, + None, + )?; + Ok(Self { + recipient_scan_key, + input_vin, + ecdh_shared_secret: shared_secret, + dleq_proof: proof, + }) + } + + pub fn new_unchecked( + recipient_scan_key: PublicKey, + input_vin: usize, + ecdh_shared_secret: PublicKey, + dleq_proof: DleqProof, + ) -> Self { + Self { + recipient_scan_key, + input_vin, + ecdh_shared_secret, + dleq_proof, + } + } + + pub fn recipient_scan_key(&self) -> &PublicKey { + &self.recipient_scan_key + } + + pub fn input_vin(&self) -> usize { + self.input_vin + } + + pub fn as_ecdh_shared_secret(&self) -> &PublicKey { + &self.ecdh_shared_secret + } + + pub fn dleq_proof(&self) -> &DleqProof { + &self.dleq_proof + } + + pub fn verify_dleq_proof( + &self, + secp: &Secp256k1, + input_pubkey: &PublicKey, + ) -> Result<()> { + let is_valid = verify_dleq_proof( + secp, + input_pubkey, + &self.recipient_scan_key, + &self.ecdh_shared_secret, + &self.dleq_proof, + None, + ) + .map_err(Error::from)?; + if !is_valid { + return Err(Error::GenericError("Invalid DLEQ proof".to_owned())); + } + Ok(()) + } +} + +/// ECDH share for all eligible inputs combined. +/// +/// Built by summing private keys first ([`Self::new_from_summed_keys`]). +/// DLEQ proofs are generated at construction time and verified before use. +pub struct GlobalSenderEcdhShare { + recipient_scan_key: PublicKey, + ecdh_shared_secret: PublicKey, + dleq_proof: DleqProof, +} + +#[expect(clippy::missing_const_for_fn)] +impl GlobalSenderEcdhShare { + pub fn new_from_summed_keys( + secp: &Secp256k1, + recipient_scan_key: PublicKey, + summed_keys: NonEmptyArray, + aux_rand: &[u8; 32], + ) -> Result { + let secret_key = summed_keys.sum_keys()?; + let shared_secret = ecdh_multiply(&recipient_scan_key, &secret_key)?; + let proof = generate_dleq_proof(secp, &secret_key, &recipient_scan_key, aux_rand, None)?; + Ok(Self { + recipient_scan_key, + ecdh_shared_secret: shared_secret, + dleq_proof: proof, + }) + } + + pub fn new_unchecked( + recipient_scan_key: PublicKey, + ecdh_shared_secret: PublicKey, + dleq_proof: DleqProof, + ) -> Self { + Self { + recipient_scan_key, + ecdh_shared_secret, + dleq_proof, + } + } + + /// Verify the DLEQ proof against the sum of eligible input public keys. + pub fn verify_dleq_proof( + &self, + secp: &Secp256k1, + input_pubkeys: NonEmptyArray<&PublicKey>, + ) -> Result<()> { + let summed_input_pubkey = PublicKey::combine_keys(input_pubkeys.as_inner())?; + let is_valid = verify_dleq_proof( + secp, + &summed_input_pubkey, + &self.recipient_scan_key, + &self.ecdh_shared_secret, + &self.dleq_proof, + None, + ) + .map_err(Error::from)?; + if !is_valid { + return Err(Error::GenericError("Invalid DLEQ proof".to_owned())); + } + Ok(()) + } + + pub fn recipient_scan_key(&self) -> &PublicKey { + &self.recipient_scan_key + } + + pub fn as_ecdh_shared_secret(&self) -> &PublicKey { + &self.ecdh_shared_secret + } + + pub fn dleq_proof(&self) -> &DleqProof { + &self.dleq_proof + } + + pub fn into_ecdh_shared_secret(self) -> PublicKey { + self.ecdh_shared_secret + } +} + +#[cfg(test)] +mod tests { + use super::*; + use secp256k1::Secp256k1; + use std::str::FromStr as _; + + #[test] + fn global_share_dleq_roundtrip() { + let secp = Secp256k1::new(); + let private_key = + SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000001") + .unwrap(); + let scan_priv = + SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000002") + .unwrap(); + let recipient_scan_key = PublicKey::from_secret_key(&secp, &scan_priv); + let summed_input_pubkey = PublicKey::from_secret_key(&secp, &private_key); + let aux_rand = [3u8; 32]; + + let global_share = GlobalSenderEcdhShare::new_from_summed_keys( + &secp, + recipient_scan_key, + NonEmptyArray::new(&[NormalizedSecretKey::new(&secp, private_key, false)]).unwrap(), + &aux_rand, + ) + .unwrap(); + + global_share + .verify_dleq_proof(&secp, NonEmptyArray::new(&[&summed_input_pubkey]).unwrap()) + .unwrap(); + } + + #[test] + fn partial_share_dleq_roundtrip() { + let secp = Secp256k1::new(); + let private_key = + SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000003") + .unwrap(); + let scan_priv = + SecretKey::from_str("0000000000000000000000000000000000000000000000000000000000000004") + .unwrap(); + let recipient_scan_key = PublicKey::from_secret_key(&secp, &scan_priv); + let input_pubkey = PublicKey::from_secret_key(&secp, &private_key); + let normalized = NormalizedSecretKey::new(&secp, private_key, false); + let aux_rand = [5u8; 32]; + + let partial = + PartialSenderEcdhShare::new(&secp, recipient_scan_key, 0, &normalized, &aux_rand) + .unwrap(); + + partial.verify_dleq_proof(&secp, &input_pubkey).unwrap(); + } +} From 57edd61005259b8f75698468168b5c82f5e2441c Mon Sep 17 00:00:00 2001 From: Sosthene Date: Mon, 24 Aug 2026 17:34:45 +0200 Subject: [PATCH 05/13] feat(silentpayments): new sending API and migrate spdk-wallet Replace `PartialSecret`-based generate_recipient_pubkeys with a DLEQ-aware API taking a `TransactionSharedSecret` per scan key. Remove legacy `calculate_partial_secret` helpers and update spdk-wallet spending to use `TransactionSharedSecret` and `GlobalSenderEcdhShare`. Update the `rand` feature of `bitcoin` to `rand-std`, needed for `OsRng` --- Cargo.toml | 4 +- silentpayments/README.md | 6 +- silentpayments/src/lib.rs | 7 +- silentpayments/src/sending.rs | 88 +++++++++--------- silentpayments/src/utils/common.rs | 11 --- silentpayments/src/utils/sending.rs | 128 +------------------------- silentpayments/tests/vector_tests.rs | 81 +++++++++++----- spdk-wallet/src/client/spend.rs | 132 ++++++++++++++++++++------- spdk-wallet/src/client/structs.rs | 7 +- 9 files changed, 217 insertions(+), 247 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 901d6107..d44d8cc8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,8 +21,8 @@ anyhow = "1.0" bech32 = "0.9" serde = { version = "1.0.188", features = ["derive"] } serde_json = "1.0.107" -bip321 = { git = "https://gitlab.com/Sosthene00/bark.git", rev = "83ab79264159869503b16fa475e0ed61ffa33174", default-features = false } -bitcoin = { version = "0.32.8", features = ["serde", "rand", "base64"] } +bip321 = { git="https://gitlab.com/Sosthene00/bark.git", rev="83ab79264159869503b16fa475e0ed61ffa33174", default-features = false } +bitcoin = { version = "0.32.8", features = ["serde", "rand-std", "base64"] } bitcoin_hashes = "0.14" rayon = "1.10.0" tokio = { version = "1", features = ["macros", "rt-multi-thread"] } diff --git a/silentpayments/README.md b/silentpayments/README.md index 4e2e56e9..963a7922 100644 --- a/silentpayments/README.md +++ b/silentpayments/README.md @@ -31,11 +31,7 @@ This will only pull `secp256k1` as a dependency, giving you access to the core t ## Sending -For sending to silent payment recipients, you can call the [`generate_recipient_pubkeys`](sending::generate_recipient_pubkeys) function. -This function takes a list of silent payment recipients (as [`SilentPaymentKeyMaterial`]), as well as a [`PartialSecret`](utils::sending::PartialSecret). - -The [`PartialSecret`](utils::sending::PartialSecret) represents the sum of all input private keys multiplied with the input hash. -To compute the [`PartialSecret`](utils::sending::PartialSecret), the [`calculate_partial_secret`](utils::sending::calculate_partial_secret) function can be used, although this requires exposing secret data to this library. +For sending to silent payment recipients, build a `TransactionSharedSecret` per recipient scan key using `GlobalSenderEcdhShare` (single signer) or `PartialSenderEcdhShare` (collaborative), then call `sending::generate_recipient_pubkeys` with the recipient key material and the shared secrets map. ## Receiving diff --git a/silentpayments/src/lib.rs b/silentpayments/src/lib.rs index ae9667aa..05130b22 100644 --- a/silentpayments/src/lib.rs +++ b/silentpayments/src/lib.rs @@ -36,10 +36,9 @@ pub use rust_dleq::DleqProof; pub use utils::common::Network; #[cfg(feature = "encode")] pub use utils::common::SilentPaymentCode; +pub use utils::common::SilentPaymentKeyMaterial; +pub use utils::common::SpVersion; #[cfg(any(feature = "sending", feature = "receiving"))] -pub use utils::common::TransactionInputs; -#[cfg(any(feature = "sending", feature = "receiving"))] -pub use utils::common::TransactionSharedSecret; -pub use utils::common::{SilentPaymentKeyMaterial, SpVersion}; +pub use utils::common::{NonEmptyArray, TransactionInputs, TransactionSharedSecret}; pub type Result = std::result::Result; diff --git a/silentpayments/src/sending.rs b/silentpayments/src/sending.rs index d378d0d6..e384d5ba 100644 --- a/silentpayments/src/sending.rs +++ b/silentpayments/src/sending.rs @@ -1,93 +1,99 @@ //! The sending component of silent payments. //! -//! The [`generate_recipient_pubkeys`] function can be used to create outputs for a list of silent -//! payment recipients. +//! The [`generate_recipient_pubkeys`] function creates taproot output keys for silent payment recipients. //! -//! Using [`generate_recipient_pubkeys`] will require calculating a -//! `partial_secret` beforehand. -//! To do this, you can use -//! [`calculate_partial_secret`](crate::utils::sending::calculate_partial_secret) from the `utils` -//! module. See the [tests on github](https://github.com/cygnet3/rust-silentpayments/blob/master/tests/vector_tests.rs) -//! for a concrete example. +//! Callers must supply a [`TransactionSharedSecret`] per unique recipient scan key. +//! On the sender side, build secrets from a [`GlobalSenderEcdhShare`](crate::utils::sending::GlobalSenderEcdhShare) +//! or from combined [`PartialSenderEcdhShare`](crate::utils::sending::PartialSenderEcdhShare)s. +//! See [the test vectors](https://github.com/cygnet3/spdk/blob/master/silentpayments/tests/vector_tests.rs) +//! for a full example. use std::collections::HashMap; use secp256k1::{PublicKey, Secp256k1, XOnlyPublicKey}; -use crate::utils::common::{SilentPaymentKeyMaterial, TransactionSharedSecret, calculate_t_n}; -use crate::utils::sending::{PartialSecret, calculate_ecdh_shared_secret}; +use crate::utils::common::SilentPaymentKeyMaterial; +use crate::utils::common::TransactionSharedSecret; +use crate::utils::common::calculate_t_n; use crate::{Error, Result}; -/// Create outputs for a given set of silent payment recipients and their corresponding shared -/// secrets. +/// Create taproot output keys for a set of silent payment recipients. /// -/// When creating the outputs for a transaction, this function should be used to generate the output -/// keys. -/// -/// This function should only be used once per transaction! If used multiple times, output key reuse -/// may occur. +/// Recipients are grouped by scan key. Within each group the BIP352 output-index counter `n` +/// increments in the order the key material entries appear in `recipients`, so callers must pass +/// them in their intended output order. Calling this function more than once for the same +/// transaction with the same `shared_secrets` will restart every `n` counter at 0, producing +/// duplicate output keys and breaking recipient privacy — call it exactly once per transaction. /// /// # Arguments /// -/// * `recipients` - An iterable list of recipients to be paid. List can contain either -/// [`SilentPaymentKeyMaterial`] or [`crate::SilentPaymentCode`]. -/// * `partial_secret` - [`PartialSecret`] that represents the sum of the private keys of eligible -/// inputs of the transaction multiplied by the input hash. +/// * `recipients` - Silent payment key material to pay, in output order. Multiple entries may +/// share the same scan key; `n` is assigned within that scan-key group in the order given. +/// * `shared_secrets` - One [`TransactionSharedSecret`] per unique scan key, keyed by that scan +/// `PublicKey`. Each entry's internally stored scan key must equal its map key. /// /// # Returns /// -/// If successful, the function returns a [Result] wrapping a [`HashMap`] of each recipient item to -/// a [Vec]. The [Vec] contains all the outputs that are associated with that recipient. -/// If the same recipient was added multiple times, this [Vec] will contain multiple elements. +/// A [`HashMap`] whose keys are the original key material entries from `recipients` and whose +/// values are the corresponding taproot [`XOnlyPublicKey`] outputs. /// /// # Errors /// /// This function will return an error if: /// +/// * A scan key has no corresponding entry in `shared_secrets`, or the entry's stored scan key +/// does not match its map key. /// * Edge cases are hit during elliptic curve computation (extremely unlikely). -pub fn generate_recipient_pubkeys( +#[expect(clippy::implicit_hasher)] +pub fn generate_recipient_pubkeys( + secp: &Secp256k1, recipients: I, - partial_secret: PartialSecret, + shared_secrets: &HashMap, ) -> Result>> where + C: secp256k1::Signing, T: Into + Eq + std::hash::Hash + Clone + Copy, I: IntoIterator, { - let secp = Secp256k1::new(); - let mut silent_payment_groups: HashMap)> = HashMap::new(); + for recipient in recipients { let key_material: SilentPaymentKeyMaterial = recipient.into(); - let recipient_scan_key = key_material.scan_key(); if let Some((_, payments)) = silent_payment_groups.get_mut(&recipient_scan_key) { payments.push(recipient); } else { - let ecdh_shared_secret = - calculate_ecdh_shared_secret(&recipient_scan_key, &partial_secret); - - silent_payment_groups.insert(recipient_scan_key, (ecdh_shared_secret, vec![recipient])); + let shared_secret = shared_secrets.get(&recipient_scan_key).ok_or_else(|| { + Error::GenericError(format!( + "Missing shared secret for scan key {recipient_scan_key}" + )) + })?; + if shared_secret.as_recipient_scan_key() != &recipient_scan_key { + return Err(Error::GenericError(format!( + "Shared secret stored under scan key {recipient_scan_key} has mismatched \ + internal scan key {}", + shared_secret.as_recipient_scan_key() + ))); + } + silent_payment_groups.insert(recipient_scan_key, (*shared_secret, vec![recipient])); } } let mut result: HashMap> = HashMap::new(); - for group in silent_payment_groups.into_values() { - let (ecdh_shared_secret, recipients) = group; - + for (ecdh_shared_secret, recipients) in silent_payment_groups.into_values() { for (n, recipient) in recipients.into_iter().enumerate() { - let recipient_key_material = recipient.into(); + let key_material: SilentPaymentKeyMaterial = recipient.into(); let n = u32::try_from(n) .map_err(|_| Error::GenericError("Recipient index exceeds u32 range".to_owned()))?; let t_n = calculate_t_n(&ecdh_shared_secret, n)?; - let res = t_n.public_key(&secp); - let reskey = res.combine(&recipient_key_material.m_pubkey())?; + let res = t_n.public_key(secp); + let reskey = res.combine(&key_material.m_pubkey())?; let (reskey_xonly, _) = reskey.x_only_public_key(); - let entry = result.entry(recipient).or_default(); - entry.push(reskey_xonly); + result.entry(recipient).or_default().push(reskey_xonly); } } Ok(result) diff --git a/silentpayments/src/utils/common.rs b/silentpayments/src/utils/common.rs index dffa21f9..b382c2c7 100644 --- a/silentpayments/src/utils/common.rs +++ b/silentpayments/src/utils/common.rs @@ -240,17 +240,6 @@ pub struct TransactionSharedSecret { #[expect(clippy::missing_const_for_fn)] impl TransactionSharedSecret { - #[cfg(feature = "sending")] - pub(crate) fn from_sender_ecdh( - ecdh_shared_secret: PublicKey, - recipient_scan_key: PublicKey, - ) -> Self { - Self { - ecdh_shared_secret, - recipient_scan_key, - } - } - /// Create a shared secret from a finalized global ECDH share (sender path). #[cfg(all( feature = "sending", diff --git a/silentpayments/src/utils/sending.rs b/silentpayments/src/utils/sending.rs index a2e48da9..9f51980c 100644 --- a/silentpayments/src/utils/sending.rs +++ b/silentpayments/src/utils/sending.rs @@ -1,27 +1,21 @@ //! Sending utility functions. //! -//! The typical flow for a single signer with DLEQ proofs is: +//! The typical flow for a single signer is: //! //! 1. Normalize input private keys with [`NormalizedSecretKey`]. //! 2. Create a [`GlobalSenderEcdhShare`] (single spender) or [`PartialSenderEcdhShare`]s (per input - collaborative transaction). //! 3. Verify BIP374 DLEQ proofs with [`PartialSenderEcdhShare::verify_dleq_proof`] / //! [`GlobalSenderEcdhShare::verify_dleq_proof`]. //! 4. Convert to a [`TransactionSharedSecret`](crate::TransactionSharedSecret), which applies the -//! BIP352 input hash. -//! -//! The legacy [`calculate_partial_secret`] / [`PartialSecret`] API remains available for callers -//! that do not need DLEQ proofs. +//! BIP352 input hash, and pass to [`generate_recipient_pubkeys`](crate::sending::generate_recipient_pubkeys). -use crate::utils::common::{NonEmptyArray, OutPoint, TransactionSharedSecret, ecdh_multiply}; +use crate::utils::common::{NonEmptyArray, ecdh_multiply}; use crate::{Error, Result}; use rust_dleq::{DleqProof, generate_dleq_proof, verify_dleq_proof}; -use secp256k1::constants::SECRET_KEY_SIZE; use secp256k1::{PublicKey, Secp256k1, SecretKey, Signing, Verification}; -use super::hash::calculate_input_hash; - -/// Guarantees that the secret key produces an even x-only public key when the spent output is -/// taproot, by negating the secret key if necessary. +/// Guarantees that the secret key produces an even x-only public key when the spent output is taproot, +/// by negating the secret key if necessary. #[derive(Debug, Clone)] pub struct NormalizedSecretKey(SecretKey); @@ -57,118 +51,6 @@ impl NonEmptyArray<'_, NormalizedSecretKey> { } } -/// Represents the sum of all eligible input private keys of a transaction, multiplied with the -/// input hash. -#[derive(Clone, Copy, Debug)] -pub struct PartialSecret(pub(crate) SecretKey); - -impl PartialSecret { - /// Re-construct the partial secret from the inner bytes. - pub fn from_slice(data: &[u8]) -> Result { - Ok(Self(SecretKey::from_slice(data)?)) - } - - /// Returns the inner bytes of the partial secret - pub fn secret_bytes(&self) -> [u8; SECRET_KEY_SIZE] { - self.0.secret_bytes() - } -} - -impl From for PartialSecret { - fn from(value: SecretKey) -> Self { - Self(value) - } -} - -impl From for SecretKey { - fn from(value: PartialSecret) -> Self { - value.0 - } -} - -/// Calculate the partial secret that is needed for generating the recipient pubkeys. -/// -/// # Arguments -/// -/// * `input_keys` - A reference to a list of tuples, each tuple containing a [`SecretKey`] and -/// [bool]. The [`SecretKey`] is the private key used in the input, and the [bool] indicates -/// whether this was from a taproot address. -/// * `outpoints_data` - The prevout outpoints used as input for this transaction. Note that the -/// txid is given in [String] format, which is displayed in reverse order from the inner byte -/// array. -/// -/// # Returns -/// -/// This function returns the partial secret, which represents the sum of all (eligible) input keys -/// multiplied with the input hash. -/// -/// # Errors -/// -/// This function will error if: -/// -/// * The input keys array is of length zero, or the summing results in an invalid key. -/// * The `outpoints_data` is of length zero, or invalid. -pub fn calculate_partial_secret( - input_keys: &[(SecretKey, bool)], - outpoints_data: &[OutPoint], -) -> Result { - let a_sum = get_a_sum_secret_keys(input_keys)?; - - let secp = Secp256k1::signing_only(); - let A_sum = a_sum.public_key(&secp); - - let outpoints = NonEmptyArray::new(outpoints_data)?; - let input_hash = calculate_input_hash(outpoints.min(), A_sum); - - Ok(PartialSecret(a_sum.mul_tweak(&input_hash)?)) -} - -/// Calculate the shared secret of a transaction. -/// -/// Since [`generate_recipient_pubkeys`](crate::sending::generate_recipient_pubkeys) calls this -/// function internally, it is not needed for the default sending flow. -/// -/// # Arguments -/// -/// * `B_scan` - The scan public key used by the wallet. -/// * `partial_secret` - the sum of all (eligible) input keys multiplied with the input hash, see -/// [`calculate_partial_secret`]. -/// -/// # Returns -/// -/// This function returns the shared secret unique to this recipient and input keys. This shared -/// secret can be used to generate output keys for the recipient. -pub fn calculate_ecdh_shared_secret( - B_scan: &PublicKey, - partial_secret: &PartialSecret, -) -> TransactionSharedSecret { - TransactionSharedSecret::from_sender_ecdh( - ecdh_multiply(B_scan, &partial_secret.0).expect("guaranteed to be a point on the curve"), - *B_scan, - ) -} - -fn get_a_sum_secret_keys(input: &[(SecretKey, bool)]) -> Result { - if input.is_empty() { - return Err(Error::GenericError("No input provided".to_owned())); - } - - let secp = Secp256k1::new(); - - let normalized: Vec = input - .iter() - .map(|(key, is_taproot)| NormalizedSecretKey::new(&secp, *key, *is_taproot)) - .collect(); - - let (head, tail) = normalized.split_first().expect("input is non-empty"); - - tail.iter() - .try_fold(*head.as_inner(), |acc, item| { - acc.add_tweak(&(*item.as_inner()).into()) - }) - .map_err(Error::from) -} - /// ECDH share for a single eligible input: `a_i * B_scan` (before input hash). /// /// Used in multi-signer flows where each party contributes one input. diff --git a/silentpayments/tests/vector_tests.rs b/silentpayments/tests/vector_tests.rs index 5709f607..6b176eea 100644 --- a/silentpayments/tests/vector_tests.rs +++ b/silentpayments/tests/vector_tests.rs @@ -2,7 +2,7 @@ mod common; #[cfg(test)] mod tests { - use std::collections::HashSet; + use std::collections::{HashMap, HashSet}; use bitcoin::hashes::Hash as _; use secp256k1::{Scalar, Secp256k1}; @@ -10,8 +10,10 @@ mod tests { use silentpayments::sending::generate_recipient_pubkeys; use silentpayments::utils::OutPoint; use silentpayments::utils::receiving::{PublicTweakData, get_pubkey_from_input, is_p2tr}; - use silentpayments::utils::sending::calculate_partial_secret; - use silentpayments::{Network, SilentPaymentCode, TransactionInputs, TransactionSharedSecret}; + use silentpayments::utils::sending::{GlobalSenderEcdhShare, NormalizedSecretKey}; + use silentpayments::{ + Network, NonEmptyArray, SilentPaymentCode, TransactionInputs, TransactionSharedSecret, + }; use crate::common::structs::TestData; use crate::common::utils::{self, verify_and_calculate_signatures}; @@ -37,26 +39,35 @@ mod tests { for sendingtest in test_case.sending { let given = sendingtest.given; let expected = sendingtest.expected; - let outpoints: Vec = given - .vin - .iter() - .map(|vin| OutPoint::from_txid_bytes_and_vout(vin.txid.to_byte_array(), vin.vout)) - .collect(); - let mut input_priv_keys = Vec::new(); - for input in given.vin { - let script_sig = input.scriptSig.as_bytes(); - let txinwitness = input.txinwitness.to_vec(); - let script_pub_key = input.prevout.scriptPubKey.hex.as_bytes(); - match get_pubkey_from_input(script_sig, &txinwitness, script_pub_key) { - Ok(Some(_pubkey)) => { - input_priv_keys.push((input.private_key, is_p2tr(script_pub_key))); - } - Ok(None) => (), + // Keep every vin. The input hash uses the smallest outpoint of the whole + // transaction, including inputs that are not silent-payment eligible. + // Private keys are summed only for inputs that yield a pubkey, matching + // `TransactionInputs::eligible_pubkeys`. + let mut inputs = TransactionInputs::with_capacity(given.vin.len()); + let mut normalized_keys = Vec::new(); + for input in given.vin { + let outpoint = + OutPoint::from_txid_bytes_and_vout(input.txid.to_byte_array(), input.vout); + let script_pub_key = input.prevout.scriptPubKey.hex.as_bytes().to_vec(); + let pubkey = match get_pubkey_from_input( + input.scriptSig.as_bytes(), + &input.txinwitness.to_vec(), + &script_pub_key, + ) { + Ok(pubkey) => pubkey, Err(e) => panic!("Problem parsing the input: {e:?}"), + }; + if pubkey.is_some() { + normalized_keys.push(NormalizedSecretKey::new( + &secp, + input.private_key, + is_p2tr(&script_pub_key), + )); } + inputs.push(outpoint, script_pub_key, pubkey); } - if input_priv_keys.is_empty() { + if normalized_keys.is_empty() { continue; } @@ -64,10 +75,30 @@ mod tests { // the wallet should make sure the amount sent are correct let silent_payment_codes = given.recipients; - // as an alternative, we could first multiply each input priv key with the input hash - // that way, we never expose the sk to our library - let partial_secret = calculate_partial_secret(&input_priv_keys, &outpoints).unwrap(); - let outputs = generate_recipient_pubkeys(silent_payment_codes, partial_secret).unwrap(); + let aux_rand = [0u8; 32]; + + let mut shared_secrets = HashMap::new(); + for payment_code in &silent_payment_codes { + let recipient_scan_key = payment_code.scan_key(); + if shared_secrets.contains_key(&recipient_scan_key) { + continue; + } + let global_share = GlobalSenderEcdhShare::new_from_summed_keys( + &secp, + recipient_scan_key, + NonEmptyArray::new(&normalized_keys).unwrap(), + &aux_rand, + ) + .unwrap(); + shared_secrets.insert( + recipient_scan_key, + TransactionSharedSecret::new_from_global_share(&secp, &global_share, &inputs) + .unwrap(), + ); + } + + let outputs = + generate_recipient_pubkeys(&secp, &silent_payment_codes, &shared_secrets).unwrap(); for output_pubkeys in &outputs { for pubkey in output_pubkeys.1 { @@ -158,8 +189,8 @@ mod tests { .unwrap(); let key_tweaks: Vec = scanned_outputs_received - .into_values() - .flat_map(|map| { + .into_iter() + .flat_map(|(_, map)| { let mut ret: Vec = vec![]; for l in map.into_values() { ret.push(l); diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index 9eecb170..2c9a0107 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -4,15 +4,17 @@ use anyhow::{Error, Result}; use bitcoin::absolute::LockTime; use bitcoin::hashes::Hash as _; use bitcoin::key::TapTweak as _; -use bitcoin::secp256k1::{Keypair, Message, Secp256k1}; +use bitcoin::secp256k1::{Keypair, Message, Secp256k1, rand}; use bitcoin::sighash::{Prevouts, SighashCache}; use bitcoin::taproot::Signature; use bitcoin::transaction::Version; use bitcoin::{ Amount, Network, OutPoint, ScriptBuf, Sequence, TapLeafHash, Transaction, TxIn, TxOut, Witness, }; -use silentpayments::utils::sending::PartialSecret; +use silentpayments::utils::sending::{GlobalSenderEcdhShare, NormalizedSecretKey}; use silentpayments::{Network as SpNetwork, SilentPaymentCode, utils as sp_utils}; +use silentpayments::{NonEmptyArray, TransactionInputs, TransactionSharedSecret}; + use spdk_core::scanner::DiscoveredOutput; use super::coin_select::{pick_utxos_for_fee_rate, select_all_utxos_for_fee_rate}; @@ -132,11 +134,13 @@ impl SpClient { ) -> Result { Self::validate_recipient_networks(&recipients, network)?; let selected_utxos = Self::resolve_selected_utxos(available_utxos, selected_outpoints)?; - let partial_secret = self.partial_secret_for_selected_utxos(&selected_utxos)?; + let shared_secrets = + self.build_shared_secrets_for_sp_transaction(&selected_utxos, &recipients)?; + Ok(SilentPaymentUnsignedTransaction { selected_utxos, recipients, - partial_secret, + shared_secrets, unsigned_tx: None, network, change, @@ -274,9 +278,12 @@ impl SpClient { }) .collect(); + let secp = Secp256k1::new(); + let sp_key_material2xonlypubkeys = silentpayments::sending::generate_recipient_pubkeys( - recipient_codes, - unsigned_transaction.partial_secret, + &secp, + &recipient_codes, + &unsigned_transaction.shared_secrets, )?; let tx_outs = unsigned_transaction @@ -419,31 +426,77 @@ impl SpClient { Ok(signed) } - pub fn partial_secret_for_selected_utxos( + fn taproot_input_pubkey( + script_pubkey: &ScriptBuf, + ) -> Result { + use silentpayments::secp256k1::{Parity, PublicKey, XOnlyPublicKey}; + let xonly = XOnlyPublicKey::from_slice(&script_pubkey.as_bytes()[2..])?; + Ok(PublicKey::from_x_only_public_key(xonly, Parity::Even)) + } + + fn sp_recipient_scan_keys( + recipients: &[Recipient], + ) -> Vec { + let mut keys = Vec::new(); + for recipient in recipients { + if let RecipientAddress::SpCode(sp_code) = &recipient.address { + let scan_key = sp_code.scan_key(); + if !keys.iter().any(|k| k == &scan_key) { + keys.push(scan_key); + } + } + } + keys + } + + fn build_shared_secrets_for_sp_transaction( &self, selected_utxos: &[(OutPoint, DiscoveredOutput)], - ) -> Result { - let b_spend = self.try_secret_spend_key()?; + recipients: &[Recipient], + ) -> Result> { + let recipient_scan_keys = Self::sp_recipient_scan_keys(recipients); + if recipient_scan_keys.is_empty() { + return Ok(HashMap::new()); + } - let outpoints = selected_utxos - .iter() - .map(|(outpoint, _)| { - Ok(sp_utils::OutPoint::from_txid_and_vout( - &outpoint.txid.to_string(), - outpoint.vout, - )?) - }) - .collect::>>()?; + let secp = Secp256k1::new(); + let b_spend = self.try_secret_spend_key()?; - let input_privkeys = selected_utxos - .iter() - .map(|(_, output)| Ok((b_spend.add_tweak(&output.tweak)?, true))) - .collect::>>()?; + let mut inputs = TransactionInputs::new(); + let mut normalized_keys = Vec::with_capacity(selected_utxos.len()); + for (outpoint, output) in selected_utxos { + let sp_outpoint = sp_utils::OutPoint::from_txid_bytes_and_vout( + outpoint.txid.to_byte_array(), + outpoint.vout, + ); + let pubkey = Self::taproot_input_pubkey(&output.txout.script_pubkey)?; + inputs.push( + sp_outpoint, + output.txout.script_pubkey.as_bytes().to_vec(), + Some(pubkey), + ); + let sk = b_spend.add_tweak(&output.tweak)?; + normalized_keys.push(NormalizedSecretKey::new(&secp, sk, true)); + } - let partial_secret = - sp_utils::sending::calculate_partial_secret(&input_privkeys, &outpoints)?; + let mut aux_rand = [0u8; 32]; + rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut aux_rand); + + let mut shared_secrets = HashMap::new(); + for recipient_scan_key in recipient_scan_keys { + let global_share = GlobalSenderEcdhShare::new_from_summed_keys( + &secp, + recipient_scan_key, + NonEmptyArray::new(&normalized_keys).expect("non-empty inputs"), + &aux_rand, + )?; + shared_secrets.insert( + recipient_scan_key, + TransactionSharedSecret::new_from_global_share(&secp, &global_share, &inputs)?, + ); + } - Ok(partial_secret) + Ok(shared_secrets) } } @@ -455,29 +508,40 @@ mod tests { use super::*; use crate::client::SpendKey; + fn test_spend_key() -> SecretKey { + SecretKey::from_slice(&[0x22; 32]).expect("valid test key") + } + fn test_client() -> SpClient { let scan_sk = SecretKey::from_slice(&[0x11; 32]).expect("valid test key"); - let spend_sk = SecretKey::from_slice(&[0x22; 32]).expect("valid test key"); - SpClient::new(scan_sk, SpendKey::Secret(spend_sk), Network::Regtest).expect("client") + SpClient::new( + scan_sk, + SpendKey::Secret(test_spend_key()), + Network::Regtest, + ) + .expect("client") } - fn discovered_output(value_sat: u64) -> DiscoveredOutput { + // The output key must match `spend_sk + tweak`, otherwise the DLEQ proof + // generated at shared-secret build time cannot verify. + fn discovered_output(spend_sk: &SecretKey, value_sat: u64) -> DiscoveredOutput { let secp = Secp256k1::new(); - let sk = SecretKey::from_slice(&[0x42; 32]).expect("valid test key"); + let tweak = Scalar::ONE; + let sk = spend_sk.add_tweak(&tweak).expect("valid tweak"); let keypair = Keypair::from_secret_key(&secp, &sk); let (xonly, _) = keypair.x_only_public_key(); - let tweaked = xonly.tap_tweak(&secp, None).0; DiscoveredOutput { - tweak: Scalar::ONE, + tweak, txout: TxOut { value: Amount::from_sat(value_sat), - script_pubkey: ScriptBuf::new_p2tr_tweaked(tweaked), + script_pubkey: ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()), }, label: None, } } fn wallet_utxos(values: &[u64]) -> HashMap { + let spend_sk = test_spend_key(); values .iter() .enumerate() @@ -485,9 +549,9 @@ mod tests { ( OutPoint::new( Txid::all_zeros(), - u32::try_from(i).expect("index fits in u32"), + u32::try_from(i).expect("vout fits in u32"), ), - discovered_output(v), + discovered_output(&spend_sk, v), ) }) .collect() diff --git a/spdk-wallet/src/client/structs.rs b/spdk-wallet/src/client/structs.rs index 3bbd20b4..b909eaf7 100644 --- a/spdk-wallet/src/client/structs.rs +++ b/spdk-wallet/src/client/structs.rs @@ -1,3 +1,4 @@ +use std::collections::HashMap; use std::str::FromStr as _; use anyhow::Error; @@ -11,7 +12,9 @@ use bitcoin::secp256k1::{PublicKey, SecretKey}; use bitcoin::{Address, Amount, Network, OutPoint, Transaction}; use serde::{Deserialize, Serialize}; use silentpayments::SilentPaymentCode; -use silentpayments::utils::sending::PartialSecret; +use silentpayments::TransactionSharedSecret; +use silentpayments::secp256k1::PublicKey as SpPublicKey; + use spdk_core::scanner::DiscoveredOutput; use super::coin_select::Strategy; @@ -62,7 +65,7 @@ pub struct Recipient { pub struct SilentPaymentUnsignedTransaction { pub selected_utxos: Vec<(OutPoint, DiscoveredOutput)>, pub recipients: Vec, - pub partial_secret: PartialSecret, + pub shared_secrets: HashMap, pub unsigned_tx: Option, pub network: Network, /// Wallet change amount (zero for drain / changeless selections). From 39a202e3cbcddbee947d2d3d34fceed05904684d Mon Sep 17 00:00:00 2001 From: Sosthene Date: Tue, 8 Sep 2026 16:18:21 +0200 Subject: [PATCH 06/13] feat(psbt): add psbt crate for BIP-375 silent payment signing Implements the BIP-375 signer roles as a new workspace crate built on top of rust-psbt (psbt-v2) and the silentpayments crate. Includes the BIP-375 test vector validation and signer e2e coverage, finalization delegated to rust-psbt's Finalizer, and correct handling of mixed global/per-input ECDH shares, labeled recipients sharing a scan key, and taproot tweaks in extract_eligible_input_pubkey. Ported from ba1e67b, adapted to SilentPaymentKeyMaterial instead of the obsolete SilentPaymentAddressRaw. Co-authored-by: macgyver13 <4712150+macgyver13@users.noreply.github.com> --- Cargo.toml | 3 + psbt/Cargo.toml | 24 + psbt/src/lib.rs | 6 + psbt/src/roles/mod.rs | 16 + psbt/src/roles/signer.rs | 854 +++++++++ psbt/tests/bip375_test_vectors.json | 2512 +++++++++++++++++++++++++++ psbt/tests/bip375_vectors.rs | 216 +++ psbt/tests/signer.rs | 956 ++++++++++ spdk-wallet/Cargo.toml | 1 + spdk-wallet/src/lib.rs | 2 +- 10 files changed, 4589 insertions(+), 1 deletion(-) create mode 100644 psbt/Cargo.toml create mode 100644 psbt/src/lib.rs create mode 100644 psbt/src/roles/mod.rs create mode 100644 psbt/src/roles/signer.rs create mode 100644 psbt/tests/bip375_test_vectors.json create mode 100644 psbt/tests/bip375_vectors.rs create mode 100644 psbt/tests/signer.rs diff --git a/Cargo.toml b/Cargo.toml index d44d8cc8..9ffe7568 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,7 @@ members = [ "spdk-wallet", "silentpayments", "scanners/local", + "psbt" ] resolver = "3" @@ -15,6 +16,7 @@ spdk-wallet = { path = "spdk-wallet" } silentpayments = { path = "silentpayments" } backend-blindbit-v1 = { path = "chain/blindbit-v1" } local-scanner = { path = "scanners/local" } +psbt = { path = "psbt" } # Core dependencies - shared across crates anyhow = "1.0" @@ -36,6 +38,7 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } +psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "2b68fa71ce9638257d38938f4ceba1218238bc47", features = ["silent-payments", "miniscript"] } rust-dleq = { git = "https://github.com/Sosthene00/rust-dleq.git", rev = "097644a14d87c454e9bd9895de2e60992ff1ba93", default-features = false } secp256k1 = { version = "0.29.0" } diff --git a/psbt/Cargo.toml b/psbt/Cargo.toml new file mode 100644 index 00000000..22eb9c6a --- /dev/null +++ b/psbt/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "psbt" +version = "0.1.0" +edition = "2021" +repository.workspace = true + +[lib] +crate-type = ["lib", "staticlib", "cdylib"] + +[features] +default = ["dleq-standalone"] +dleq-native = ["rust-dleq/native"] +dleq-standalone = ["rust-dleq/standalone"] + +[dependencies] +bitcoin.workspace = true +silentpayments.workspace = true +secp256k1.workspace = true +psbt-v2.workspace = true +rust-dleq.workspace = true + +[dev-dependencies] +serde.workspace = true +serde_json.workspace = true diff --git a/psbt/src/lib.rs b/psbt/src/lib.rs new file mode 100644 index 00000000..89bf6f0a --- /dev/null +++ b/psbt/src/lib.rs @@ -0,0 +1,6 @@ +//! BIP-375 PSBT Module +//! +//! This module contains the BIP-375 PSBT functionality: +//! - `roles`: PSBT role implementations (signer, finalizer, extractor) + +pub mod roles; diff --git a/psbt/src/roles/mod.rs b/psbt/src/roles/mod.rs new file mode 100644 index 00000000..b62389ce --- /dev/null +++ b/psbt/src/roles/mod.rs @@ -0,0 +1,16 @@ +//! BIP-375 PSBT Roles +//! +//! Implements the PSBT roles defined in BIP-174/370/375: +//! - Signer +//! +//! ## TODO: Future Enhancements +//! +//! - **Combiner role**: For async multi-party signing workflows +//! - Current examples use sequential signing (hardware-signer, multi-signer) +//! - Future enhancement: Merge PSBTs from concurrent signers +//! - Would handle union of ECDH shares, DLEQ proofs, and signatures +//! - Conflict detection for same-field different-value scenarios + +pub mod signer; + +pub use signer::*; diff --git a/psbt/src/roles/signer.rs b/psbt/src/roles/signer.rs new file mode 100644 index 00000000..519ca151 --- /dev/null +++ b/psbt/src/roles/signer.rs @@ -0,0 +1,854 @@ +//! PSBT Signer Role +//! +//! This module extends the upstream [`psbt_v2::Signer`] with the two pieces of +//! the BIP-375 signer role it does not implement: +//! +//! - **ECDH share generation** ([`SpSignerExt::add_ecdh_shares`]): global shares for a single +//! signer owning every eligible input, per-input partial shares otherwise, each with a BIP-374 +//! DLEQ proof. +//! - **SP output script derivation** ([`SpSignerExt::derive_sp_output_scripts`]): the BIP-352 +//! derivation that upstream's `commit_silent_payment_outputs` explicitly leaves to the caller. +//! +//! Signing itself is *not* re-implemented here: open an upstream `Signer::session`, +//! produce signatures with `SigningSession::get_input_sigs` (ECDSA and plain taproot +//! key spends) or `SigningSession::get_silent_payment_sigs` (BIP-376 inputs), then +//! write them with `Signer::apply`. + +use std::collections::HashMap; +use std::fmt; + +use bitcoin::key::TweakedPublicKey; +use bitcoin::{CompressedPublicKey, ScriptBuf, XOnlyPublicKey}; +use psbt_v2::{ + CommitSilentPaymentOutputsError, DetermineLockTimeError, FundingUtxoError, GetKey, Input, + KeyRequest, Psbt, Signer as UpstreamSigner, SpV0Info, +}; +use secp256k1::rand::{CryptoRng, RngCore}; +use secp256k1::{Parity, PublicKey, Scalar, Secp256k1, SecretKey, Signing, Verification}; +use silentpayments::sending::generate_recipient_pubkeys; +use silentpayments::utils::receiving::is_eligible; +use silentpayments::utils::sending::{ + GlobalSenderEcdhShare, NormalizedSecretKey, PartialSenderEcdhShare, +}; +use silentpayments::utils::{NUMS_H, OutPoint as SpOutPoint}; +use silentpayments::{ + NonEmptyArray, SilentPaymentKeyMaterial, SpVersion, TransactionInputs, TransactionSharedSecret, +}; + +#[derive(Debug)] +pub enum SpSignerError { + /// Funding UTXO missing or inconsistent for an input. + FundingUtxo(FundingUtxoError), + /// An input is BIP-352-eligible but its pubkey cannot be named from the PSBT + /// (e.g. P2WPKH without a matching `bip32_derivations` entry). The receiver + /// will learn it from the finalized witness, so deriving without it would + /// commit to the wrong input set. + MissingInputPubkey { vin: usize }, + /// No ECDH share for this scan key on the given input. + MissingShare { + scan_key: CompressedPublicKey, + vin: usize, + }, + /// A share without its DLEQ proof (`vin: None` = global share). + MissingDleqProof { + scan_key: CompressedPublicKey, + vin: Option, + }, + /// `sp_tweak` is not a valid secp256k1 scalar. + InvalidSpTweak { vin: usize }, + /// Structurally malformed input (e.g. `sp_tweak` set on a non-P2TR input). + MalformedInput { vin: usize, detail: &'static str }, + /// [`ShareMode::Global`]: an eligible input's key could not be resolved from the + /// provided [`GetKey`], so the global share cannot cover every input. + KeyResolution { vin: usize }, + /// The [`GetKey`] backend errored during a lookup. + GetKey { vin: usize, error: String }, + /// [`ShareMode::Partial`]: none of the inputs are owned by the provided keys. + NoOwnedInputs, + /// Shares for the requested mode already exist; refusing to overwrite. + SharesAlreadyPresent, + /// Global and per-input partial shares must not coexist when *adding* + /// shares (derivation tolerates the mix per BIP-375: the global share + /// takes precedence). + MixedShareState, + /// A signature is already present; BIP-375 requires shares before signatures. + AlreadySigned { vin: usize }, + /// silentpayments crypto layer failure. + SilentPayments(silentpayments::Error), + /// secp256k1 failure. + Secp256k1(secp256k1::Error), + /// Upstream lock-time determination failed when constructing the commit signer. + DetermineLockTime(DetermineLockTimeError), + /// Upstream `commit_silent_payment_outputs` rejected the derived scripts. + CommitOutputs(CommitSilentPaymentOutputsError), +} + +impl fmt::Display for SpSignerError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use SpSignerError as E; + match self { + E::FundingUtxo(e) => write!(f, "funding utxo error: {e}"), + E::MissingInputPubkey { vin } => write!( + f, + "input {vin}: BIP-352 eligible but its pubkey cannot be named from the PSBT" + ), + E::MissingShare { scan_key, vin } => { + write!(f, "no ECDH share for scan key {scan_key} on input {vin}") + } + E::MissingDleqProof { + scan_key, + vin: Some(vin), + } => write!(f, "no DLEQ proof for scan key {scan_key} on input {vin}"), + E::MissingDleqProof { + scan_key, + vin: None, + } => write!( + f, + "no DLEQ proof for the global share of scan key {scan_key}" + ), + E::InvalidSpTweak { vin } => write!(f, "input {vin}: sp_tweak is not a valid scalar"), + E::MalformedInput { vin, detail } => write!(f, "input {vin}: malformed: {detail}"), + E::KeyResolution { vin } => write!( + f, + "single signer cannot resolve the spending key for eligible input {vin}" + ), + E::GetKey { vin, error } => write!(f, "input {vin}: GetKey backend error: {error}"), + E::NoOwnedInputs => f.write_str("no inputs owned by the provided keys"), + E::SharesAlreadyPresent => { + f.write_str("ECDH shares already present, refusing to overwrite") + } + E::MixedShareState => f.write_str("global and per-input ECDH shares must not coexist"), + E::AlreadySigned { vin } => write!( + f, + "input {vin} already carries a signature; shares must be added before signing" + ), + E::SilentPayments(e) => write!(f, "silent payments error: {e}"), + E::Secp256k1(e) => write!(f, "secp256k1 error: {e}"), + E::DetermineLockTime(e) => write!(f, "cannot determine lock time: {e}"), + E::CommitOutputs(e) => write!(f, "failed to commit silent payment outputs: {e}"), + } + } +} + +impl std::error::Error for SpSignerError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + use SpSignerError as E; + match self { + E::FundingUtxo(e) => Some(e), + E::SilentPayments(e) => Some(e), + E::Secp256k1(e) => Some(e), + _ => None, + } + } +} + +impl From for SpSignerError { + fn from(value: FundingUtxoError) -> Self { + Self::FundingUtxo(value) + } +} + +impl From for SpSignerError { + fn from(value: silentpayments::Error) -> Self { + Self::SilentPayments(value) + } +} + +impl From for SpSignerError { + fn from(value: secp256k1::Error) -> Self { + Self::Secp256k1(value) + } +} + +impl From for SpSignerError { + fn from(value: DetermineLockTimeError) -> Self { + Self::DetermineLockTime(value) + } +} + +impl From for SpSignerError { + fn from(value: CommitSilentPaymentOutputsError) -> Self { + Self::CommitOutputs(value) + } +} + +/// Who am I in this transaction? Explicit, not auto-detected. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ShareMode { + /// I own every eligible input: write global shares (BIP-375 single-signer path). + /// Errors loudly if any eligible input's key can't be resolved. + Global, + /// I own some inputs: write per-input partial shares for owned inputs only, + /// skip the rest. + Partial, +} + +pub trait SpSignerExt { + /// BIP-375 signer, phase 1: add ECDH shares + DLEQ proofs for every scan key + /// among the SP outputs. Returns the scan keys that received shares so the + /// caller can verify coverage before forwarding the PSBT. + /// + /// No-op (returning an empty vec) when the PSBT has no SP outputs. + /// + /// # Errors + /// + /// - [`SpSignerError::AlreadySigned`] if any input already carries a signature (BIP-375 + /// requires shares before signatures). + /// - [`SpSignerError::SharesAlreadyPresent`] / [`SpSignerError::MixedShareState`] if shares + /// already exist. + /// - [`SpSignerError::KeyResolution`] ([`ShareMode::Global`]) if an eligible input's key cannot + /// be resolved. + /// - [`SpSignerError::NoOwnedInputs`] ([`ShareMode::Partial`]) if no input is owned by `keys`. + fn add_ecdh_shares( + &mut self, + secp: &Secp256k1, + rng: &mut R, + keys: &K, + mode: ShareMode, + ) -> Result, SpSignerError> + where + C: Signing + Verification, + R: RngCore + CryptoRng, + K: GetKey; + + /// BIP-352, phase 2: derive output scripts from whatever shares are present + /// (global or aggregated partial). Pure — no mutation. Output-index keyed so + /// it feeds upstream `commit_silent_payment_outputs` directly. + /// + /// When a scan key has both a global share and per-input shares, the global + /// share takes precedence (BIP-375 "Computing the Output Scripts"); if it + /// fails verification, complete per-input coverage is tried as a fallback + /// (sound: a verified partial proof binds its share to the input's key). + fn derive_sp_output_scripts( + &self, + secp: &Secp256k1, + ) -> Result, SpSignerError> + where + C: Signing + Verification; + + /// Single-signer convenience: derive + commit in one step. The commit is + /// upstream's `commit_silent_payment_outputs`, which runs the BIP-375 signer + /// checks and clears the modifiable flags. `self` is left untouched on error. + fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> + where + C: Signing + Verification; +} + +impl SpSignerExt for Psbt { + fn add_ecdh_shares( + &mut self, + secp: &Secp256k1, + rng: &mut R, + keys: &K, + mode: ShareMode, + ) -> Result, SpSignerError> + where + C: Signing + Verification, + R: RngCore + CryptoRng, + K: GetKey, + { + let scan_keys = collect_scan_keys(&collect_sp_v0_keys(self)); + if scan_keys.is_empty() { + // No SP outputs: nothing to do. + return Ok(Vec::new()); + } + + // BIP-375: shares are added before any signature. A signature present at + // this point means the output scripts are already committed and adding + // shares can only produce an inconsistent PSBT. + for (vin, input) in self.inputs.iter().enumerate() { + if !input.partial_sigs.is_empty() || input.tap_key_sig.is_some() { + return Err(SpSignerError::AlreadySigned { vin }); + } + } + + match mode { + ShareMode::Global => { + if !self.global.sp_ecdh_shares.is_empty() { + return Err(SpSignerError::SharesAlreadyPresent); + } + if self.inputs.iter().any(|i| !i.sp_ecdh_shares.is_empty()) { + return Err(SpSignerError::MixedShareState); + } + + // A single signer owns every input that contributes to the ECDH, + // so resolving each of them is mandatory. Inputs excluded by + // convention (non-eligible scripts, NUMS_H internal key) are + // skipped, mirroring what the receiver will do. + let mut summed_keys: Vec = + Vec::with_capacity(self.inputs.len()); + for (vin, input) in self.inputs.iter().enumerate() { + if !is_ecdh_contributing(input)? { + continue; + } + let input_key = resolve_owned_eligible_key(secp, input, vin, keys)? + .ok_or(SpSignerError::KeyResolution { vin })?; + let is_taproot = funding_output(input)?.script_pubkey.is_p2tr(); + summed_keys.push(NormalizedSecretKey::new(secp, input_key, is_taproot)); + } + + let summed_keys = NonEmptyArray::new(&summed_keys)?; + let mut global_shares = Vec::with_capacity(scan_keys.len()); + for scan_key in &scan_keys { + let mut aux_rand = [0u8; 32]; + rng.fill_bytes(&mut aux_rand); + let global_share = GlobalSenderEcdhShare::new_from_summed_keys( + secp, + scan_key.0, + summed_keys, + &aux_rand, + )?; + global_shares.push((*scan_key, global_share)); + } + for (scan_key, global_share) in global_shares { + self.global.sp_ecdh_shares.insert( + scan_key, + CompressedPublicKey(*global_share.as_ecdh_shared_secret()), + ); + self.global + .sp_dleq_proofs + .insert(scan_key, to_psbt_dleq(*global_share.dleq_proof())); + } + } + ShareMode::Partial => { + if !self.global.sp_ecdh_shares.is_empty() { + return Err(SpSignerError::MixedShareState); + } + + // First pass: resolve every owned input and validate, so the PSBT + // is never left half-written when a later input errors. + let mut owned: Vec<(usize, NormalizedSecretKey)> = Vec::new(); + for (vin, input) in self.inputs.iter().enumerate() { + // Only contribute shares for inputs this signer actually owns. + let Some(input_key) = resolve_owned_eligible_key(secp, input, vin, keys)? + else { + continue; + }; + if scan_keys + .iter() + .any(|k| input.sp_ecdh_shares.contains_key(k)) + { + return Err(SpSignerError::SharesAlreadyPresent); + } + let is_taproot = funding_output(input)?.script_pubkey.is_p2tr(); + owned.push((vin, NormalizedSecretKey::new(secp, input_key, is_taproot))); + } + if owned.is_empty() { + return Err(SpSignerError::NoOwnedInputs); + } + + // Build every share before writing. `PartialSenderEcdhShare::new` can + // fail on a later scan key, and an insert already stored would leave + // the PSBT half-written. + let mut partials = Vec::with_capacity(owned.len() * scan_keys.len()); + for (vin, normalized) in &owned { + for scan_key in &scan_keys { + let mut aux_rand = [0u8; 32]; + rng.fill_bytes(&mut aux_rand); + let partial = PartialSenderEcdhShare::new( + secp, scan_key.0, *vin, normalized, &aux_rand, + )?; + partials.push((*vin, *scan_key, partial)); + } + } + for (vin, scan_key, partial) in partials { + let input = &mut self.inputs[vin]; + input.sp_ecdh_shares.insert( + scan_key, + CompressedPublicKey(*partial.as_ecdh_shared_secret()), + ); + input + .sp_dleq_proofs + .insert(scan_key, to_psbt_dleq(*partial.dleq_proof())); + } + } + } + + Ok(scan_keys) + } + + fn derive_sp_output_scripts( + &self, + secp: &Secp256k1, + ) -> Result, SpSignerError> + where + C: Signing + Verification, + { + // Recipient key material per SP output. `generate_recipient_pubkeys` assigns + // the BIP-352 n-counter within each scan-key group in the order entries are + // given, and the reference vectors expect that order to be the outputs sorted + // by `sp_v0_info` (ties broken by output index) — not raw output order. This + // matters when one scan key is paid with different labels. + let sp_outputs = collect_sp_v0_keys(self); + if sp_outputs.is_empty() { + return Ok(Vec::new()); + } + + let sorted_materials: Vec = sp_outputs + .iter() + .map(|(_, sp_info)| sp_info_to_key_material(sp_info)) + .collect(); + + let scan_keys = collect_scan_keys(&sp_outputs); + + // The BIP-352 input set, exactly as the receiver rebuilds it. + let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count); + for (vin, input) in self.inputs.iter().enumerate() { + let outpoint = SpOutPoint::from_txid_and_vout( + &input.previous_txid.to_string(), + input.spent_output_index, + )?; + let spk = funding_output(input)?.script_pubkey.to_bytes(); + let pubkey = extract_eligible_input_pubkey(input)?; + if pubkey.is_none() && is_ecdh_contributing(input)? { + return Err(SpSignerError::MissingInputPubkey { vin }); + } + transaction_inputs.push(outpoint, spk, pubkey); + } + let eligible_vins = transaction_inputs.eligible_vins(); + + // Aggregate of every eligible input's partial share for one scan key. + // Primary source when no global share exists, fallback when the global + // share fails verification (see below). + let partials_secret = + |ck: CompressedPublicKey| -> Result { + // Every eligible input must provide a partial share with its proof. + let mut partials = Vec::with_capacity(eligible_vins.len()); + for &vin in &eligible_vins { + let input = &self.inputs[vin]; + let share = input + .sp_ecdh_shares + .get(&ck) + .ok_or(SpSignerError::MissingShare { scan_key: ck, vin })?; + let proof = + input + .sp_dleq_proofs + .get(&ck) + .ok_or(SpSignerError::MissingDleqProof { + scan_key: ck, + vin: Some(vin), + })?; + partials.push(PartialSenderEcdhShare::new_unchecked( + ck.0, + vin, + share.0, + to_rust_dleq(*proof), + )); + } + Ok(TransactionSharedSecret::new_from_partial_shares( + secp, + ck.0, + NonEmptyArray::new(&partials)?, + &transaction_inputs, + )?) + }; + + // One transaction shared secret per scan key. DLEQ proofs are verified + // inside the `TransactionSharedSecret` constructors. + let mut shared_secrets: HashMap = + HashMap::with_capacity(scan_keys.len()); + for ck in scan_keys { + // A global share takes precedence (BIP-375 "Computing the Output + // Scripts": use PSBT_GLOBAL_SP_ECDH_SHARE "if available"). Combiners + // can legitimately produce PSBTs that also carry per-input shares for + // the same scan key — the official vectors treat that state as valid + // — so coexisting partials never replace a *verifiable* global share. + // We never *produce* the overlap ourselves: `add_ecdh_shares` rejects + // it. + // + // Fallback: when the global share fails verification, complete partial + // coverage is tried before giving up. This is sound because a verified + // partial DLEQ proof binds its share to the input's prevout pubkey, + // so fully verified partials determine the one correct secret — the + // fallback can only recover that value or fail, never commit to a + // wrong one. If the fallback fails too, the original global error is + // reported. A *missing* global proof does not fall back: BIP-375 + // lists it as an invalid state. + let scan_key = ck.0; + let shared_secret = if let Some(share) = self.global.sp_ecdh_shares.get(&ck) { + let proof = + self.global + .sp_dleq_proofs + .get(&ck) + .ok_or(SpSignerError::MissingDleqProof { + scan_key: ck, + vin: None, + })?; + let global = + GlobalSenderEcdhShare::new_unchecked(scan_key, share.0, to_rust_dleq(*proof)); + TransactionSharedSecret::new_from_global_share(secp, &global, &transaction_inputs) + .or_else(|global_err| partials_secret(ck).map_err(|_| global_err))? + } else { + partials_secret(ck)? + }; + shared_secrets.insert(scan_key, shared_secret); + } + + let mut derived = generate_recipient_pubkeys(secp, sorted_materials, &shared_secrets)?; + + // Assign back in output-index order: within one key material the sorted + // order coincides with index order, so popping per material is exact. + let mut scripts = Vec::with_capacity(sp_outputs.len()); + for (index, sp_info) in sp_outputs { + let key_material = sp_info_to_key_material(&sp_info); + let keys = derived + .get_mut(&key_material) + .expect("every submitted recipient is derived"); + let xonly = keys + .first() + .copied() + .expect("one derived key per submitted recipient"); + keys.remove(0); + scripts.push(( + index, + ScriptBuf::new_p2tr_tweaked(TweakedPublicKey::dangerous_assume_tweaked(xonly)), + )); + } + Ok(scripts) + } + + fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> + where + C: Signing + Verification, + { + let scripts = self.derive_sp_output_scripts(secp)?; + // Upstream commit: refuses script mismatches, clears the modifiable flags + // (without clobbering SIGHASH_SINGLE) and runs the BIP-375 signer checks. + // Operate on a clone so `self` stays untouched on error. + let mut signer = UpstreamSigner::new(self.clone())?; + signer.commit_silent_payment_outputs(scripts)?; + *self = signer.psbt(); + Ok(()) + } +} + +/// Distinct scan keys among the SP outputs. It must be called with the output of +/// `collect_sp_v0_keys` to guarantee it is sorted. We still sort the keys before deduping to be +/// sure. +fn collect_scan_keys(sp_v0_info: &[(usize, SpV0Info)]) -> Vec { + let mut res: Vec<_> = sp_v0_info.iter().map(|(_, x)| x.scan_key()).collect(); + res.sort_unstable(); + res.dedup(); + res +} + +/// Funding output used to classify a BIP-352 input. +/// +/// [`Input::funding_utxo_untrusted`] still rejects inconsistent UTXO data +/// (mismatched txid, mismatched witness and non-witness outputs, missing or +/// out-of-range outputs). BIP-375's vectors, and the PSBTs this role is asked +/// to finish, often carry only a witness UTXO for non-P2TR inputs. That +/// accessor reports [`FundingUtxoError::UnverifiableUtxo`] in that case. The +/// script is the one BIP-352 hashes, and this role does not use the amount, so +/// that single error falls back to `witness_utxo`. +/// +/// A witness-only non-P2TR script is the creator's claim. Callers that have +/// their own UTXO set should check it before trusting the resulting shares. +fn funding_output(input: &Input) -> Result<&bitcoin::TxOut, FundingUtxoError> { + match input.funding_utxo_untrusted() { + Err(FundingUtxoError::UnverifiableUtxo) => input + .witness_utxo + .as_ref() + .ok_or(FundingUtxoError::UnverifiableUtxo), + result => result, + } +} + +/// Build the v0 key material from the `sp_v0_info` scan and spend keys. +fn sp_info_to_key_material(sp_info: &SpV0Info) -> SilentPaymentKeyMaterial { + SilentPaymentKeyMaterial::new(SpVersion::ZERO, sp_info.scan_key().0, sp_info.spend_key().0) +} + +/// Collects all the sp v0 keys in psbt's outputs with their output index, already sorted according +/// to BIP375 +fn collect_sp_v0_keys(psbt: &Psbt) -> Vec<(usize, SpV0Info)> { + let mut res: Vec<_> = psbt + .outputs + .iter() + .enumerate() + .filter_map(|(i, o)| o.sp_v0_info.map(|sp_info| (i, sp_info))) + .collect(); + res.sort_unstable_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0))); + res +} + +/// Extract the BIP-352 input public key from PSBT input fields. +/// +/// Returns `Some(pubkey)` for each eligible script type: +/// - **P2TR**: reads the output key from the funding scriptPubKey, promoted to even parity (BIP-352 +/// §3). This also covers SP inputs (`sp_tweak` set): per BIP-376 the `sp_spend_bip32_derivations` +/// map key is the *untweaked* spend key `B_spend`, used only for signer key lookup — the key used +/// for ECDH is the output key itself, which is `B_spend + tweak·G` by construction. Reading it +/// from the prevout instead of a separately declared field is what makes a wrong or malicious +/// `sp_tweak` fail closed at key-resolution time. +/// - **P2TR without `sp_tweak`**: a NUMS_H `tap_internal_key` is skipped only when +/// `tap_merkle_root` retweaks that key to the funding scriptPubKey (BIP-352 §3). A NUMS claim +/// that does not reproduce the prevout is still eligible. SP inputs (`sp_tweak` set) always have +/// a key path, so the exception does not apply to them. +/// - **P2WPKH / P2PKH**: reads from `bip32_derivations`. +/// - **P2SH-P2WPKH**: checks that `redeem_script` is P2WPKH, then reads from `bip32_derivations`. +/// +/// Returns `Ok(None)` when the input does not contribute to the ECDH, when the required +/// PSBT fields are missing, or when no `bip32_derivations` entry verifies against the +/// funding script. Callers that require a pubkey for every contributing input (share +/// generation in [`ShareMode::Global`], output derivation) must turn that `None` into an +/// error themselves. +pub fn extract_eligible_input_pubkey(input: &Input) -> Result, SpSignerError> { + if !is_ecdh_contributing(input)? { + return Ok(None); + } + + let funding_utxo = funding_output(input)?; + let spk = &funding_utxo.script_pubkey; + + if spk.is_p2tr() { + // BIP-352 §3: use the taproot **output key** (from the scriptPubKey), not the + // internal key. The sender signs with the tweaked private key and the receiver + // reads the same key from the scriptPubKey. + let output_xonly = XOnlyPublicKey::from_slice(&spk.as_bytes()[2..])?; + Ok(Some(output_xonly.public_key(Parity::Even))) + } else if spk.is_p2sh() { + let Some(redeem_script) = input.redeem_script.as_ref() else { + return Ok(None); + }; + Ok(input + .bip32_derivations + .keys() + .find(|pk| pubkey_matches_funding_script(pk, spk, Some(redeem_script))) + .map(|pk| pk.inner)) + } else { + // P2WPKH / P2PKH: the pubkey must verify against the funding script — + // otherwise the derived secret commits to a key the receiver never sees. + Ok(input + .bip32_derivations + .keys() + .find(|pk| pubkey_matches_funding_script(pk, spk, None)) + .map(|pk| pk.inner)) + } +} + +/// Whether BIP-352 expects this input to contribute to the ECDH aggregation: an +/// eligible script, excluding the NUMS_H script-path-only exception (§3). The +/// exception applies only when `tap_internal_key` is NUMS_H and `tap_merkle_root` +/// retweaks it to the funding scriptPubKey — an unauthenticated NUMS claim does +/// not. It also does not apply to SP inputs (`sp_tweak` set): they always have a +/// key path. +/// +/// P2SH contributes only as P2SH-P2WPKH, which is only knowable from the redeem +/// script — a bare P2SH input (or one without `redeem_script` set yet) is +/// treated as non-contributing. +fn is_ecdh_contributing(input: &Input) -> Result { + let spk = &funding_output(input)?.script_pubkey; + if !is_eligible(spk.as_bytes()) { + return Ok(false); + } + if spk.is_p2sh() { + return Ok(input.redeem_script.as_ref().is_some_and(|r| r.is_p2wpkh())); + } + if spk.is_p2tr() && input.sp_tweak.is_none() && is_nums_script_path_only(input, spk) { + return Ok(false); + } + Ok(true) +} + +/// BIP-352 §3 script-path-only exception. +/// +/// `tap_internal_key` and `tap_merkle_root` are not committed to by the prevout, so a +/// NUMS claim counts only when tweaking NUMS_H by that merkle root reproduces +/// `script_pubkey`. +fn is_nums_script_path_only(input: &Input, script_pubkey: &bitcoin::ScriptBuf) -> bool { + let Some(internal_key) = input.tap_internal_key else { + return false; + }; + if internal_key.serialize() != NUMS_H { + return false; + } + let Some(merkle_root) = input.tap_merkle_root else { + return false; + }; + let secp = Secp256k1::verification_only(); + bitcoin::ScriptBuf::new_p2tr(&secp, internal_key, Some(merkle_root)) == *script_pubkey +} + +/// Resolve the private key for an eligible input owned by `keys`. +/// +/// The lookup strategy mirrors upstream signing so that the set of inputs we +/// contribute ECDH shares for is exactly the set of inputs we can later sign: +/// +/// - **SP P2TR** (`sp_tweak` set): requests the *untweaked* spend key from +/// `sp_spend_bip32_derivations` (BIP-32 first, then pubkey), falling back to candidate spend keys +/// recovered from the output key when the map is empty — the same fallback rust-psbt's +/// `Input::silent_payment_secret_key` uses. The tweak is applied after lookup and verified +/// against the prevout's output key, so a wrong or malicious `sp_tweak` fails closed here. +/// - **Plain P2TR**: requests the even-lifted output key by pubkey, like upstream's taproot +/// key-spend path in `SigningSession::get_input_sigs`. +/// - **P2WPKH / P2PKH / P2SH-P2WPKH**: iterates `bip32_derivations`, but only after verifying the +/// pubkey against the funding script — a wrong pubkey here produces a share the receiver can +/// never match. +/// +/// Returns `Ok(None)` for inputs that are not eligible or not owned by `keys`. +fn resolve_owned_eligible_key( + secp: &Secp256k1, + input: &Input, + vin: usize, + keys: &K, +) -> Result, SpSignerError> +where + C: Signing + Verification, + K: GetKey, +{ + let funding_utxo = funding_output(input)?; + let spk = &funding_utxo.script_pubkey; + + if !is_eligible(spk.as_bytes()) { + return Ok(None); + } + + let get = |req: KeyRequest| -> Result, SpSignerError> { + keys.get_key(&req, secp) + .map(|opt| opt.map(|sk| sk.inner)) + .map_err(|e| SpSignerError::GetKey { + vin, + error: format!("{e:?}"), + }) + }; + + if let Some(tweak_bytes) = input.sp_tweak { + if !spk.is_p2tr() { + return Err(SpSignerError::MalformedInput { + vin, + detail: "sp_tweak set on a non-P2TR input", + }); + } + let tweak = Scalar::from_be_bytes(tweak_bytes) + .map_err(|_| SpSignerError::InvalidSpTweak { vin })?; + let output_xonly = XOnlyPublicKey::from_slice(&spk.as_bytes()[2..34])?; + + // BIP-376: the derivation map is keyed by the *untweaked* spend key. + for (spend_key, key_source) in &input.sp_spend_bip32_derivations { + let sk = match get(KeyRequest::Bip32(key_source.clone()))? { + Some(sk) => Some(sk), + None => get(KeyRequest::Pubkey(bitcoin::PublicKey::from(*spend_key)))?, + }; + if let Some(tweaked) = + sk.and_then(|sk| apply_tweak_and_verify(secp, sk, tweak, output_xonly)) + { + return Ok(Some(tweaked)); + } + } + + // Fallback for an unpopulated map: recover candidate spend keys from the + // output key, mirroring rust-psbt's signing fallback. + if input.sp_spend_bip32_derivations.is_empty() { + for candidate in spend_key_candidates(output_xonly, tweak, secp) { + if let Some(tweaked) = get(KeyRequest::Pubkey(candidate))? + .and_then(|sk| apply_tweak_and_verify(secp, sk, tweak, output_xonly)) + { + return Ok(Some(tweaked)); + } + } + } + return Ok(None); + } + + if spk.is_p2tr() { + // Exception (BIP-352 §3): a script-path-only NUMS output has no key to contribute. + if is_nums_script_path_only(input, spk) { + return Ok(None); + } + let output_xonly = XOnlyPublicKey::from_slice(&spk.as_bytes()[2..34])?; + let request = bitcoin::PublicKey::new(output_xonly.public_key(Parity::Even)); + return Ok(get(KeyRequest::Pubkey(request))? + .filter(|sk| sk.x_only_public_key(secp).0 == output_xonly)); + } + + // P2WPKH / P2PKH / P2SH-P2WPKH. + for (pk, key_source) in &input.bip32_derivations { + if !pubkey_matches_funding_script(pk, spk, input.redeem_script.as_ref()) { + continue; + } + let sk = match get(KeyRequest::Bip32(key_source.clone()))? { + Some(sk) => Some(sk), + None => get(KeyRequest::Pubkey(*pk))?, + }; + if let Some(sk) = sk.filter(|sk| sk.public_key(secp) == pk.inner) { + return Ok(Some(sk)); + } + } + Ok(None) +} + +/// Apply `sp_tweak` to a candidate spend key and check it produces the prevout's +/// output key (x-only comparison). This is the fail-closed BIP-376 tweak check. +fn apply_tweak_and_verify( + secp: &Secp256k1, + spend_sk: SecretKey, + tweak: Scalar, + output_key: XOnlyPublicKey, +) -> Option { + let tweaked = spend_sk.add_tweak(&tweak).ok()?; + (tweaked.x_only_public_key(secp).0 == output_key).then_some(tweaked) +} + +/// Candidate untweaked spend keys for an SP output key: `output_key - tweak·G` +/// under both parities. Mirrors rust-psbt's private `spend_key_candidates`. +fn spend_key_candidates( + output_key: XOnlyPublicKey, + tweak: Scalar, + secp: &Secp256k1, +) -> Vec { + if tweak == Scalar::ZERO { + return [Parity::Even, Parity::Odd] + .into_iter() + .map(|p| bitcoin::PublicKey::new(output_key.public_key(p))) + .collect(); + } + let Ok(tweak_sk) = SecretKey::from_slice(&tweak.to_be_bytes()) else { + return Vec::new(); + }; + let negated_tweak_key = tweak_sk.public_key(secp).negate(secp); + [Parity::Even, Parity::Odd] + .into_iter() + .filter_map(|p| output_key.public_key(p).combine(&negated_tweak_key).ok()) + .map(bitcoin::PublicKey::new) + .collect() +} + +/// Check that `pubkey` is the key committed by the funding scriptPubKey. +fn pubkey_matches_funding_script( + pubkey: &bitcoin::PublicKey, + spk: &ScriptBuf, + redeem_script: Option<&ScriptBuf>, +) -> bool { + if spk.is_p2wpkh() { + return pubkey + .wpubkey_hash() + .is_ok_and(|h| ScriptBuf::new_p2wpkh(&h) == *spk); + } + if spk.is_p2pkh() { + return ScriptBuf::new_p2pkh(&pubkey.pubkey_hash()) == *spk; + } + if spk.is_p2sh() { + let Some(redeem) = redeem_script else { + return false; + }; + return redeem.is_p2wpkh() + && ScriptBuf::new_p2sh(&redeem.script_hash()) == *spk + && pubkey + .wpubkey_hash() + .is_ok_and(|h| ScriptBuf::new_p2wpkh(&h) == *redeem); + } + false +} + +/// Convert a `rust_dleq` proof into the PSBT-serializable proof type. +/// +/// Both are newtypes over the same 64-byte encoding. +fn to_psbt_dleq(p: rust_dleq::DleqProof) -> psbt_v2::DleqProof { + psbt_v2::DleqProof(p.0) +} + +/// Convert a PSBT-field DLEQ proof into the rust-dleq type used by `silentpayments`. +fn to_rust_dleq(p: psbt_v2::DleqProof) -> rust_dleq::DleqProof { + rust_dleq::DleqProof(p.0) +} diff --git a/psbt/tests/bip375_test_vectors.json b/psbt/tests/bip375_test_vectors.json new file mode 100644 index 00000000..27bc747e --- /dev/null +++ b/psbt/tests/bip375_test_vectors.json @@ -0,0 +1,2512 @@ +{ + "description": "BIP-375 Test Vectors", + "version": "1.2.0", + "notes": [ + "Generated by https://github.com/macgyver13/bip375-test-generator/", + "Each vector includes: base64-encoded psbt and description", + "Supplementary material (hex, inputs, outputs, sp_proofs) is included for diagnostics and should not be used for validation", + "'checks' overrides the validation sequence, e.g. skip structure checks to test input eligibility" + ], + "invalid": [ + { + "description": "psbt structure: missing PSBT_OUT_SP_V0_INFO field when PSBT_OUT_SP_V0_LABEL set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQDA0MWZ04xLnQHpSq5jI2/aAbRMT5OsRKl39Iml2eMiwwIgfd311m6QKccuNVB0fZJjffaj5C4W9UJpdPi+uF0mIcABAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIGHMBAAAAAAABBCJRIBe/gYp0DI0Tuy5Y5sq4rrsiY8+rt5QENxNV46aiiaG0AQoEAQAAAAA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100c0d0c599d38c4b9d01e94aae63236fda01b44c4f93ac44a977f489a5d9e322c302207dddf5d66e9029c72e3550747d92637df6a3e42e16f5426974f8beb85d2621c00101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021000103081873010000000000010422512017bf818a740c8d13bb2e58e6cab8aebb2263cfabb79404371355e3a6a289a1b4010a040100000000", + "task": "fail_deserialize" + } + }, + { + "description": "psbt structure: incorrect byte length for PSBT_OUT_SP_V0_INFO field", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwgYcwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUECekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84AA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010941027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce000", + "task": "fail_deserialize" + } + }, + { + "description": "psbt structure: incorrect byte length for PSBT_IN_SP_ECDH_SHARE field", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GggA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QoiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEDCBhzAQAAAAAAAQQiUSBkb0lMoLubzq0UuNt+TGlEVh+vIy58zMNr3VhpX3SRWQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682003eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "task": "fail_deserialize" + } + }, + { + "description": "psbt structure: incorrect byte length for PSBT_IN_SP_DLEQ field", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4Gg/ihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgAAEDCBhzAQAAAAAAAQQiUSBkb0lMoLubzq0UuNt+TGlEVh+vIy58zMNr3VhpX3SRWQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0683f8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3200001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "task": "fail_deserialize" + } + }, + { + "description": "psbt structure: PSBT_GLOBAL_TX_MODIFIABLE field is non-zero when PSBT_OUT_SCRIPT set for sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEBAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwgYcwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010101fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159" + } + ], + "task": "fail_sign" + } + }, + { + "description": "psbt structure: missing PSBT_OUT_SCRIPT field when sending to non-sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCTDMtMl1wmVr6/9mlBKycpeg3DlJS0y+DuhXpHwOpobgIgNKBkNH18RgAxoQYT8IBMqDwncNq+uFh3IH0rf6qmXv0BAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIGHMBAAAAAAAA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100930ccb4c975c2656bebff669412b27297a0dc39494b4cbe0ee857a47c0ea686e022034a064347d7c460031a10613f0804ca83c2770dabeb85877207d2b7faaa65efd0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308187301000000000000", + "task": "fail_deserialize" + } + }, + { + "description": "ecdh coverage: only one ineligible P2SH multisig input when PSBT_OUT_SCRIPT set for sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAFMCAAAAAXyoMfPUiQn+aMsOqqoR+Hc97n6McwhTN1kOJLsGOQ20AAAAAAD/////AaCGAQAAAAAAF6kU2OZohxTu7Qqi7dSJqhyjwXFwHk2HAAAAAAEER1IhAr5Ar99ismPLfe4rmF0cOP5BsZlNKwUHU0PRcsIY6rHEIQJ6R5JT0AogWhCpQ483IBm582TgqDaAC/g529KOfOa5VVKuAQ4gzTgaRVCP49nKtjt+D3BKD1adv9VamBAtnqM67mIbdfQBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgzeOdiwW0lvjxjyCyfQr5oyMzCeBHIhnggT/ztdN4fikBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001005302000000017ca831f3d48909fe68cb0eaaaa11f8773dee7e8c73085337590e24bb06390db40000000000ffffffff01a08601000000000017a914d8e6688714eeed0aa2edd489aa1ca3c171701e4d8700000000010447522102be40afdf62b263cb7dee2b985d1c38fe41b1994d2b05075343d172c218eab1c421027a479253d00a205a10a9438f372019b9f364e0a836800bf839dbd28e7ce6b95552ae010e20cd381a45508fe3d9cab63b7e0f704a0f569dbfd55a98102d9ea33aee621b75f4010f0400000000011004feffffff00010308905f0100000000000104225120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e29010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "", + "public_key": "", + "prevout_txid": "f4751b62ee3aa39e2d10985ad5bf9d560f4a700f7e3bb6cad9e38f50451a38cd", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "02000000017ca831f3d48909fe68cb0eaaaa11f8773dee7e8c73085337590e24bb06390db40000000000ffffffff01a08601000000000017a914d8e6688714eeed0aa2edd489aa1ca3c171701e4d8700000000", + "sequence": 4294967294, + "signed": false + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: missing PSBT_IN_SP_ECDH_SHARE field for input 0 when PSBT_OUT_SCRIPT set for sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEBHxAnAAAAAAAAFgAUNyH6c8IwXLL4joSJLWvWuXcmHmoBAwQBAAAAIgYCQ6DUDp3giCeUFhdSuuQrqQlSeEIJ8GNDDwryVjVKhbsIAAAAgAEAAAABDiCT02M2J+tY6dwwP275yxvoDBZhNzq+im1o30frVfCaGwEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAuV6etywGNj7MVToDBS5elCZS0I1aEHqn8ExcGFEAOY3Ih4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhA9/o4HeILO0WcbkJsYhPUF1MI8kgqROMyhCMmJNTa/Vcymb868WqzAsViY2OjfUSHB/fnoevqBke8zUhiA7srpgABAwgYcwEAAAAAAAEEIlEgzeOdiwW0lvjxjyCyfQr5oyMzCeBHIhnggT/ztdN4fikBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff0001011f10270000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a0103040100000022060243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb080000008001000000010e2093d3633627eb58e9dc303f6ef9cb1be80c1661373abe8a6d68df47eb55f09a1b010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682102e57a7adcb018d8fb3154e80c14b97a50994b42356841ea9fc13170614400e637221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840f7fa381de20b3b459c6e426c6213d4175308f2482a44e33284232624d4dafd573299bf3af16ab302c5626363a37d448707f7e7a1ebea0647bccd486203bb2ba60001030818730100000000000104225120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e29010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "1b9af055eb47df686d8abe3a3761160ce81bcbf96e3f30dce958eb273663d393", + "prevout_index": 0, + "amount": 10000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff0110270000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "10270000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "02e57a7adcb018d8fb3154e80c14b97a50994b42356841ea9fc13170614400e637", + "dleq_proof": "f7fa381de20b3b459c6e426c6213d4175308f2482a44e33284232624d4dafd573299bf3af16ab302c5626363a37d448707f7e7a1ebea0647bccd486203bb2ba6", + "input_index": 1 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: missing PSBT_IN_SP_DLEQ field for input when PSBT_IN_SP_ECDH_SHARE set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbAAEDCBhzAQAAAAAAAQQiUSBkb0lMoLubzq0UuNt+TGlEVh+vIy58zMNr3VhpX3SRWQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b0001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": null, + "input_index": 0 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: missing PSBT_GLOBAL_SP_DLEQ field when PSBT_GLOBAL_SP_ECDH_SHARE set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEiBgLIF7t1Ia/DXqlvO/snDm61Dd/6VWBie5Yf7ADymWUIvwgAAACAAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQMIGHMBAAAAAAABBCJRIGRvSUygu5vOrRS4235MaURWH68jLnzMw2vdWGlfdJFZAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "supplementary": { + "hex": "70736274ff010204020000000104010101050101010601002207027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b01fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e01220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff0001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b" + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: invalid proof in PSBT_IN_SP_DLEQ field", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIG9hTKsWyAwmppZy4viq5wvAiLUgLqne/2rOeM2n+2JyAiAQVYeP/VlnUGDrYKAL+jNMnLJB+6EoTBEkkNEA2ex8LgEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAbvHreDwFl9ZoVl4787j95b7SgVKV9D4XAVEk1EXcy9rdKkne51lhePEhbl1NuRdP/dpjNON8kDEQjAjOE3TeDwABAwgYcwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068406ef1eb783c0597d668565e3bf3b8fde5bed2815295f43e17015124d445dccbdadd2a49dee7596178f1216e5d4db9174ffdda6334e37c9031108c08ce1374de0f0001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "6ef1eb783c0597d668565e3bf3b8fde5bed2815295f43e17015124d445dccbdadd2a49dee7596178f1216e5d4db9174ffdda6334e37c9031108c08ce1374de0f", + "input_index": 0 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: invalid proof in PSBT_GLOBAL_SP_DLEQ field", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhA58j9RCuU2IoqaiyStDRkj6AHyf4IBHKjN4DQtSMoRNCb2Is/7obRLUOGxGV/u3heLS8Uv8+RhXQ/4SrIJQ+V2QH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/RzBEAiBvYUyrFsgMJqaWcuL4qucLwIi1IC6p3v9qznjNp/ticgIgEFWHj/1ZZ1Bg62CgC/ozTJyyQfuhKEwRJJDRANnsfC4BIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEDCBhzAQAAAAAAAQQiUSBkb0lMoLubzq0UuNt+TGlEVh+vIy58zMNr3VhpX3SRWQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "supplementary": { + "hex": "70736274ff010204020000000104010101050101010601002207027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b2208027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840e7c8fd442b94d88a2a6a2c92b434648fa007c9fe080472a33780d0b5232844d09bd88b3fee86d12d4386c4657fbb785e2d2f14bfcf9185743fe12ac8250f95d901fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402206f614cab16c80c26a69672e2f8aae70bc088b5202ea9deff6ace78cda7fb627202201055878ffd59675060eb60a00bfa334c9cb241fba1284c112490d100d9ec7c2e01220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff0001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "2430479d2da1310a024d2aab8e4c7b49d76cd51f45ee8127c159b0393a675b6f75c581ebe3d0817ddaf3bb598cfd7a022f1a87ed479664f6b947a47db5941cb2" + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: missing PSBT_IN_BIP32_DERIVATION field for input when PSBT_IN_SP_DLEQ set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEDCBhzAQAAAAAAAQQiUSBkb0lMoLubzq0UuNt+TGlEVh+vIy58zMNr3VhpX3SRWQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: output 1 missing ECDH share for scan key with one input / three sp outputs (different scan keys)", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQMBBgEAAfsEAgAAAAABAR9ADQMAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g/S309Ytav5uR/xoeQ+LjUj9QxqoZ1cIjYBQexIyagCEBDwQAAAAAARAE/v///yIdArlFYVfpRu8H90tU+gm+Sn6Tjcr7+ye0s3LFc8BZ8SqwIQLChkR0sISqyB9uMKxe30ZnOTzmBNgI0/SZoJhOi1JJdCIdA2UdLAc/ywKk2C3aU/HVAdd6A1BmZ5hUZHOyEmts0afeIQN2iSMnxOeAru7UzhvJK7ASK3t5ENlvCtUUi0lvnD6S+yIeArlFYVfpRu8H90tU+gm+Sn6Tjcr7+ye0s3LFc8BZ8SqwQPCxHVHD/ROzjgpsjvwu4Mpxdzr2dLMVHmiSFJJcS1fIFojJ4Hi3UIhabKsoa1d+k6JJfrSWNrGvG2vILnyRElEiHgNlHSwHP8sCpNgt2lPx1QHXegNQZmeYVGRzshJrbNGn3kCY8UrEWvZFmrDITUfaU2TPsUT/kL2scy+cq8bbAA3PGpXjsx97cKBCmKUbb9RRbIHXFsmVT4rxDD1ZgJruK704AAEDCJBfAQAAAAAAAQQiUSBg9n1lOOjDNhoPtXryD47AzuIAMtDb3yc6UykBnOW/TgEJQgNlHSwHP8sCpNgt2lPx1QHXegNQZmeYVGRzshJrbNGn3gPycOClYyGDtqsBB06HfmgA2wD1x8XS+vu2j5wo1IVFJAABAwgQJwAAAAAAAAEEIlEgzeOdiwW0lvjxjyCyfQr5oyMzCeBHIhnggT/ztdN4fikBCUIDUteMQTkAMq2RgWppf8dA2OuQnPBNcIhSZLBR8jheJewC4MTBh7chX5l8hIWnW0WRtsKEd7laESO5lpItMVSGC/gAAQMIIE4AAAAAAAABBCJRIM//VLPkWViKpOGXLVboPI42pZ2WjLKZ3vuvBMJDlKnuAQlCArlFYVfpRu8H90tU+gm+Sn6Tjcr7+ye0s3LFc8BZ8SqwAhJoHj8J6uOKjy8/7NfdVvxYbPoCjoqzP3KpD4QKbSJcAA==", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501030106010001fb04020000000001011f400d0300000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20fd2df4f58b5abf9b91ff1a1e43e2e3523f50c6aa19d5c22360141ec48c9a8021010f0400000000011004feffffff221d02b9456157e946ef07f74b54fa09be4a7e938dcafbfb27b4b372c573c059f12ab02102c2864474b084aac81f6e30ac5edf4667393ce604d808d3f499a0984e8b524974221d03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de210376892327c4e780aeeed4ce1bc92bb0122b7b7910d96f0ad5148b496f9c3e92fb221e02b9456157e946ef07f74b54fa09be4a7e938dcafbfb27b4b372c573c059f12ab040f0b11d51c3fd13b38e0a6c8efc2ee0ca71773af674b3151e689214925c4b57c81688c9e078b750885a6cab286b577e93a2497eb49636b1af1b6bc82e7c911251221e03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de4098f14ac45af6459ab0c84d47da5364cfb144ff90bdac732f9cabc6db000dcf1a95e3b31f7b70a04298a51b6fd4516c81d716c9954f8af10c3d59809aee2bbd3800010308905f010000000000010422512060f67d6538e8c3361a0fb57af20f8ec0cee20032d0dbdf273a5329019ce5bf4e01094203651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de03f270e0a5632183b6ab01074e877e6800db00f5c7c5d2fafbb68f9c28d48545240001030810270000000000000104225120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e290109420352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec02e0c4c187b7215f997c8485a75b4591b6c28477b95a1123b996922d3154860bf800010308204e0000000000000104225120cfff54b3e459588aa4e1972d56e83c8e36a59d968cb299defbaf04c24394a9ee01094202b9456157e946ef07f74b54fa09be4a7e938dcafbfb27b4b372c573c059f12ab00212681e3f09eae38a8f2f3fecd7dd56fc586cfa028e8ab33f72a90f840a6d225c00", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "21809a8cc41e146023c2d519aac6503f52e3e2431e1aff919bbf5a8bf5f42dfd", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01400d0300000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "400d0300000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de", + "ecdh_share": "0376892327c4e780aeeed4ce1bc92bb0122b7b7910d96f0ad5148b496f9c3e92fb", + "dleq_proof": "98f14ac45af6459ab0c84d47da5364cfb144ff90bdac732f9cabc6db000dcf1a95e3b31f7b70a04298a51b6fd4516c81d716c9954f8af10c3d59809aee2bbd38", + "input_index": 0 + }, + { + "scan_key": "02b9456157e946ef07f74b54fa09be4a7e938dcafbfb27b4b372c573c059f12ab0", + "ecdh_share": "02c2864474b084aac81f6e30ac5edf4667393ce604d808d3f499a0984e8b524974", + "dleq_proof": "f0b11d51c3fd13b38e0a6c8efc2ee0ca71773af674b3151e689214925c4b57c81688c9e078b750885a6cab286b577e93a2497eb49636b1af1b6bc82e7c911251", + "input_index": 0 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: input 1 missing ECDH share for output 1 with two inputs / two sp outputs (different scan keys)", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQIBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsIQMJH9SAORd/RNe3npYWiEnGLrP4eADEZ2fFCo84+Y79FSIdA2UdLAc/ywKk2C3aU/HVAdd6A1BmZ5hUZHOyEmts0afeIQN2iSMnxOeAru7UzhvJK7ASK3t5ENlvCtUUi0lvnD6S+yIeA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsQL4acjrvVeiYG5lZmpvBKzj4froBWMxwZokPImnK3kY7dzQal9KScZZNAcAkHMMi/VOQwpuZFg+CbzKTZYmMvwIiHgNlHSwHP8sCpNgt2lPx1QHXegNQZmeYVGRzshJrbNGn3kCY8UrEWvZFmrDITUfaU2TPsUT/kL2scy+cq8bbAA3PGpXjsx97cKBCmKUbb9RRbIHXFsmVT4rxDD1ZgJruK704AAEBH6CGAQAAAAAAFgAUNyH6c8IwXLL4joSJLWvWuXcmHmoBAwQBAAAAIgYCQ6DUDp3giCeUFhdSuuQrqQlSeEIJ8GNDDwryVjVKhbsIAAAAgAEAAAABDiDnbAFxCDpMX7Sv4vbWHwCkcwG50B+NLkd4CrdULjd8CAEPBAAAAAABEAT+////Ih0DZR0sBz/LAqTYLdpT8dUB13oDUGZnmFRkc7ISa2zRp94hAnUEQAf+LQMNV3wymRzyo+deU1BCRbPL5bMFOufF8iBaIh4DZR0sBz/LAqTYLdpT8dUB13oDUGZnmFRkc7ISa2zRp95AOLnjgGtJvr7vxs7gZcKwZv2wCuzs8ei1sqr0fPBBeyma4KJW7Xy2yCcC63E31zv1eSccQoTQBuO1nXCpuWfYiQABAwiQXwEAAAAAAAEEIlEgUYxvb4GbCpCxtzrI2r6I+6L7jU21kKWeh5y2htZLPwoBCUIDZR0sBz/LAqTYLdpT8dUB13oDUGZnmFRkc7ISa2zRp94D8nDgpWMhg7arAQdOh35oANsA9cfF0vr7to+cKNSFRSQAAQMIkF8BAAAAAAABBCJRIJPCrCoXvlxLW2ZvyHz2ESYroSl4aKSY4YV32/tFpEJwAQlCA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsAuDEwYe3IV+ZfISFp1tFkbbChHe5WhEjuZaSLTFUhgv4AA==", + "supplementary": { + "hex": "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", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "087c372e54b70a78472e8d1fd0b90173a4001fd6f6e2afb45f4c3a0871016ce7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de", + "ecdh_share": "0376892327c4e780aeeed4ce1bc92bb0122b7b7910d96f0ad5148b496f9c3e92fb", + "dleq_proof": "98f14ac45af6459ab0c84d47da5364cfb144ff90bdac732f9cabc6db000dcf1a95e3b31f7b70a04298a51b6fd4516c81d716c9954f8af10c3d59809aee2bbd38", + "input_index": 0 + }, + { + "scan_key": "0352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec", + "ecdh_share": "03091fd48039177f44d7b79e96168849c62eb3f87800c46767c50a8f38f98efd15", + "dleq_proof": "be1a723aef55e8981b99599a9bc12b38f87eba0158cc7066890f2269cade463b77341a97d29271964d01c0241cc322fd5390c29b99160f826f329365898cbf02", + "input_index": 0 + }, + { + "scan_key": "03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de", + "ecdh_share": "0275044007fe2d030d577c32991cf2a3e75e53504245b3cbe5b3053ae7c5f2205a", + "dleq_proof": "38b9e3806b49bebeefc6cee065c2b066fdb00aececf1e8b5b2aaf47cf0417b299ae0a256ed7cb6c82702eb7137d73bf579271c4284d006e3b59d70a9b967d889", + "input_index": 1 + } + ], + "task": "fail_sign" + } + }, + { + "description": "ecdh coverage: input 1 missing ECDH share for scan key with two inputs / one sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR9QwwAAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g6xHhra18MFGah0Q1Mm7jehlliBwKVcouqa/tQZZIthYBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEfUMMAAAAAAAAWABQ3IfpzwjBcsviOhIkta9a5dyYeaiIGAkOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7CAAAAIABAAAAAQ4g245T4MzJHLEs15uROavlPi9D3Liqq6r37/AsHsiwHCgBDwQAAAAAARAE/v///wABAwgYcwEAAAAAAAEEIlEgzeOdiwW0lvjxjyCyfQr5oyMzCeBHIhnggT/ztdN4fikBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001011f50c30000000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20eb11e1adad7c30519a874435326ee37a1965881c0a55ca2ea9afed419648b616010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001011f50c30000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a22060243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb080000008001000000010e20db8e53e0ccc91cb12cd79b9139abe53e2f43dcb8aaabaaf7eff02c1ec8b01c28010f0400000000011004feffffff0001030818730100000000000104225120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e29010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "16b6489641edafa92eca550a1c8865197ae36e323544879a51307cadade111eb", + "prevout_index": 0, + "amount": 50000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff0150c30000000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "50c30000000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "281cb0c81e2cf0eff7aaabaab8dc432f3ee5ab39919bd72cb11cc9cce0538edb", + "prevout_index": 0, + "amount": 50000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff0150c30000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "50c30000000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "task": "fail_sign" + } + }, + { + "description": "input eligibility: segwit version greater than 1 in transaction inputs with sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABZSFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQD/G0d7SFEcnvURdIK0VbinRBzrmgXCDZ4gwhD+Z4IEJAIgJ32Cr+1Q28AA/sbFs+Rp61l2dsYw+TpBveyIolGGf00BAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g0w9eTlaTsy1vWnieNwu2RHFBjAHb48ufI2BmfBwTOaUBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIGHMBAAAAAAABBCJRIPGzmH+N0VjGTWFO/Otm7DX662b5nu+5arlL2tCh6dqAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001652141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100ff1b477b48511c9ef5117482b455b8a7441ceb9a05c20d9e20c210fe678204240220277d82afed50dbc000fec6c5b3e469eb597676c630f93a41bdec88a251867f4d0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20d30f5e4e5693b32d6f5a789e370bb64471418c01dbe3cb9f2360667c1c1339a5010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120f1b3987f8dd158c64d614efceb66ec35faeb66f99eefb96ab94bdad0a1e9da80010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "a539131c7c6660239fcbe3db018c417144b60b379e785a6f2db393564e5e0fd3", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001652141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001652141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "task": "fail_sign" + }, + "checks": [ + "input_eligibility" + ] + }, + { + "description": "input eligibility: non-SIGHASH_ALL signature on input with sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCID1lvc+owIu6KcBlzqbELkBAvrwUG9UvgfUD9jrZiAZUAiBGU0AdzeUC8dVS4BTFAgx1UerNOncuiYVMYBgzYyB9FAEBAwQCAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwgYcwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402203d65bdcfa8c08bba29c065cea6c42e4040bebc141bd52f81f503f63ad988065402204653401dcde502f1d552e014c5020c7551eacd3a772e89854c60183363207d140101030402000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "task": "fail_sign" + } + }, + { + "description": "output scripts: P2TR input with NUMS internal key cannot derive sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABASsQJwAAAAAAACJRICG+i0nY1uxr8GEwJe9oKFeYqXr2DtXaB7tet9ZpYewfAQMEAQAAAAEOIH+QX5ugy7b4HNdKHstiYMqtPm+AQQ5JLIv1XAj9zv6iAQ8EAAAAAAEQBP7///9BFNMsopJrMi8UXXbPyLBj7jj06YS1J1xwXHfzaeotwZjXywLWLIhtqqDoD+Oihy6ICzLHNSrQOqcQ70op/TJd8D5BdOvTC5iMb90n5znTaWSj5nvrmsw9N0hd1L9Iy5QYvoe/x32ScF6OyZcN7h1d+TXOTBJBP8nlOygqhfF6r1NwXwEiFcBQkpt0waBJVLeLS2A16XpeB4paDyjsltVHv+6azoA6wCMg0yyikmsyLxRdds/IsGPuOPTphLUnXHBcd/Np6i3BmNeswAEXIFCSm3TBoElUt4tLYDXpel4HiloPKOyW1Ue/7prOgDrAIh0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAm4w8ShPbGbAm3ZU73IN2M0+RUEpUQvGp9jwNFV8+IWiIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhALSLEJgdzB0pUmyzfewhQr2VRMuHIb12djTXH8g2q8ODua7McdrYjqJxie6BN6aGesgacQt2Yi3EKmm4KpRUGWAABAwgcJQAAAAAAAAEEIlEgOwB1kqKTFP8NUJ6d02uqJVLvwKsGsDO/0vYkCFfQAQcBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001012b102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f01030401000000010e207f905f9ba0cbb6f81cd74a1ecb6260caad3e6f80410e492c8bf55c08fdcefea2010f0400000000011004feffffff4114d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7cb02d62c886daaa0e80fe3a2872e880b32c7352ad03aa710ef4a29fd325df03e4174ebd30b988c6fdd27e739d36964a3e67beb9acc3d37485dd4bf48cb9418be87bfc77d92705e8ec9970dee1d5df935ce4c12413fc9e53b282a85f17aaf53705f012215c050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac02320d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7acc001172050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06821026e30f1284f6c66c09b7654ef720dd8cd3e454129510bc6a7d8f034557cf885a2221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068402d22c4260773074a549b2cdf7b0850af655132e1c86f5d9d8d35c7f20daaf0e0ee6bb31c76b623a89c627ba04de9a19eb2069c42dd988b710a9a6e0aa5150658000103081c2500000000000001042251203b007592a29314ff0d509e9dd36baa2552efc0ab06b033bfd2f6240857d00107010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "9dab08c8eb0a4d9984ba709d580d009608f7b117dd4620eb4209c1d67a6c29d0", + "public_key": "02d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7", + "prevout_txid": "a2fecefd085cf58b2c490e41806f3eadca6062cb1e4ad71cf8b6cba09b5f907f", + "prevout_index": 0, + "amount": 10000, + "non_witness_utxo": "020000000113f106b64b57b5b1376f9f6c47190f40cc06b3bedcb8aaba97850ab3d7f67d020000000000ffffffff01102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f00000000", + "witness_utxo": "102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "026e30f1284f6c66c09b7654ef720dd8cd3e454129510bc6a7d8f034557cf885a2", + "dleq_proof": "2d22c4260773074a549b2cdf7b0850af655132e1c86f5d9d8d35c7f20daaf0e0ee6bb31c76b623a89c627ba04de9a19eb2069c42dd988b710a9a6e0aa5150658", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 9500, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51203b007592a29314ff0d509e9dd36baa2552efc0ab06b033bfd2f6240857d00107" + } + ], + "task": "fail_sign" + } + }, + { + "description": "output scripts: PSBT_OUT_SCRIPT does not match derived sp output", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIGHMBAAAAAAABBCJRIM3jnYsFtJb48Y8gsn0K+aMjMwngRyIZ4IE/87XTeH4pAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e29010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120cde39d8b05b496f8f18f20b27d0af9a3233309e0472219e0813ff3b5d3787e29" + } + ], + "task": "fail_sign" + } + }, + { + "description": "output scripts: two sp outputs (same scan / different spend keys) not sorted lexicographically by spend key", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIExYL+wZvNCU5oIsqPD7MiK6sIG6J64r3IOIgwa67SNWAiAfxZx06/JBydKQqMxQ8qOYD8DANBNXtltjINXNPOpPBAEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwiQXwEAAAAAAAEEIlEgPajcATlIcUBND7sqMXcLxrF+r7rr33jiwy48KFZTJ1kBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgCi4D5lDNIleEbx2x1q254/iwluzMvIXshHEAXvx9nfYYAAQMIECcAAAAAAAABBCJRINcZ2dcurhCyj8MgCzL61dlJboWOixbkdXjXyMFEkzsEAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA6r4Yq7amM+SU5r33DN10dpfsGsSHvCh8DGp9zgv1T27AA==", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501020106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402204c582fec19bcd094e6822ca8f0fb3222bab081ba27ae2bdc83888306baed235602201fc59c74ebf241c9d290a8cc50f2a3980fc0c0341357b65b6320d5cd3cea4f040101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308905f01000000000001042251203da8dc01394871404d0fbb2a31770bc6b17eafbaebdf78e2c32e3c2856532759010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068028b80f994334895e11bc76c75ab6e78fe2c25bb332f217b211c4017bf1f677d860001030810270000000000000104225120d719d9d72eae10b28fc3200b32fad5d9496e858e8b16e47578d7c8c144933b04010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06803aaf862aeda98cf92539af7dc3375d1da5fb06b121ef0a1f031a9f7382fd53dbb00", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068028b80f994334895e11bc76c75ab6e78fe2c25bb332f217b211c4017bf1f677d86", + "script": "51203da8dc01394871404d0fbb2a31770bc6b17eafbaebdf78e2c32e3c2856532759" + }, + { + "output_index": 1, + "amount": 10000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06803aaf862aeda98cf92539af7dc3375d1da5fb06b121ef0a1f031a9f7382fd53dbb", + "script": "5120d719d9d72eae10b28fc3200b32fad5d9496e858e8b16e47578d7c8c144933b04" + } + ], + "task": "fail_sign" + } + }, + { + "description": "output scripts: k values assigned to wrong output indices with three sp outputs (same scan / spend keys)", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQMBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQDmsaUAuR12tiR/luLlnUQZ6/oZayCC6yzQGczKmeec6wIgVp/snmnIG0ZomQT4uGSrck/xFnuR58NgeHpzOZqLvNMBAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIkF8BAAAAAAABBCJRIGRvSUygu5vOrRS4235MaURWH68jLnzMw2vdWGlfdJFZAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AAEDCBAnAAAAAAAAAQQiUSBnO3Y1anIQCkUV5BRRrprC+6ap0dft7SIJEBvVLxrrVwEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQABAwgQJwAAAAAAAAEEIlEgpRVl2ozof5Td+ErkDvaYxXSb8mLkE+ryjVDYvYtTJ8UBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "supplementary": { + "hex": "70736274ff0102040200000001040101010501030106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100e6b1a500b91d76b6247f96e2e59d4419ebfa196b2082eb2cd019ccca99e79ceb0220569fec9e69c81b46689904f8b864ab724ff1167b91e7c360787a73399a8bbcd30101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308905f0100000000000104225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce0390001030810270000000000000104225120673b76356a72100a4515e41451ae9ac2fba6a9d1d7eded2209101bd52f1aeb57010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce0390001030810270000000000000104225120a51565da8ce87f94ddf84ae40ef698c5749bf262e413eaf28d50d8bd8b5327c5010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159" + }, + { + "output_index": 1, + "amount": 10000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120673b76356a72100a4515e41451ae9ac2fba6a9d1d7eded2209101bd52f1aeb57" + }, + { + "output_index": 2, + "amount": 10000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120a51565da8ce87f94ddf84ae40ef698c5749bf262e413eaf28d50d8bd8b5327c5" + } + ], + "task": "fail_sign" + } + } + ], + "valid": [ + { + "description": "can finalize: one P2PKH input single-signer", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAFUCAAAAAfTCEtWu0ef2/2M/LOCcZHxXvt2TAxTZjed1A9WOlAszAAAAAAD/////AaCGAQAAAAAAGXapFB4q14ctMpQTpW3wlovjOCIngxY7iKwAAAAAIgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCKz65hp7Ug/wQxkrbclMyEJpEkQIMSdkyI3dldqY0pVQIgIIfDsRj5aZKk2iQTz/6RcPJQ4n48FMtd7z5jjDDX6oABAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4gUidI6xd2TSjKSUgV7I1J59MNUrxzQix8hut045cFcpQBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIGHMBAAAAAAABBCJRIOFA0oe0W0bNTqr6Q3cGFXC6voPRuLyVCnSp/qCSM9emAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABAFUCAAAAAfTCEtWu0ef2/2M/LOCcZHxXvt2TAxTZjed1A9WOlAszAAAAAAD/////AaCGAQAAAAAAGXapFB4q14ctMpQTpW3wlovjOCIngxY7iKwAAAAAAQdrSDBFAiEAis+uYae1IP8EMZK23JTMhCaRJECDEnZMiN3ZXamNKVUCICCHw7EY+WmSpNokE8/+kXDyUOJ+PBTLXe8+Y4ww1+qAASECyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8BDiBSJ0jrF3ZNKMpJSBXsjUnn0w1SvHNCLHyG63TjlwVylAEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwgYcwEAAAAAAAEEIlEg4UDSh7RbRs1OqvpDdwYVcLq+g9G4vJUKdKn+oJIz16YBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb0402000000000100550200000001f4c212d5aed1e7f6ff633f2ce09c647c57bedd930314d98de77503d58e940b330000000000ffffffff01a0860100000000001976a9141e2ad7872d329413a56df0968be338222783163b88ac00000000220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf4830450221008acfae61a7b520ff043192b6dc94cc84269124408312764c88ddd95da98d295502202087c3b118f96992a4da2413cffe9170f250e27e3c14cb5def3e638c30d7ea800101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20522748eb17764d28ca494815ec8d49e7d30d52bc73422c7c86eb74e397057294010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001030818730100000000000104225120e140d287b45b46cd4eaafa4377061570babe83d1b8bc950a74a9fea09233d7a6010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "94720597e374eb867c2c4273bc520dd3e7498dec154849ca284d7617eb482752", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001f4c212d5aed1e7f6ff633f2ce09c647c57bedd930314d98de77503d58e940b330000000000ffffffff01a0860100000000001976a9141e2ad7872d329413a56df0968be338222783163b88ac00000000", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120e140d287b45b46cd4eaafa4377061570babe83d1b8bc950a74a9fea09233d7a6" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two inputs single-signer using global ECDH share", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAtMmJyM1JgfoT8r3ZR+NLWN+Agrqht+tgNMGzU9Iz8xiIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAxlO3H5RoGKlb3DnwkYRFvJA6CHa3OAYOnl2x3Owwq99U4LXxeFc/URnecapjrRm0SeO8tlRjk2yLrupNkXOSuQH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/SDBFAiEA7BqWeJn9r3jg2rH/VnzzA3wMo9G7Im8q7sP98KfSmdcCIBHdNztMi7HrfRAkJSDvxy+E7Un3b0H78IdNp0bjoGOoASIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///wABAR+ghgEAAAAAABYAFKaSURwHlXW/N1bavFatcdQoSmkOIgIC9bWfpeSSIh6/Vbp4rUQmBb6ulRZroeujJQ0Luqx+LtxIMEUCIQDelwGo+8K1FHCnn5V0LTz/267tYvzpJKCg1dcFYFFTxQIgRd8PiHo5I7pLMWKTtgzZ/xAdiZUqfbBpxHlWMzJ8PKIBIgYC9bWfpeSSIh6/Vbp4rUQmBb6ulRZroeujJQ0Luqx+LtwIAAAAgAEAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////AAEDCBhzAQAAAAAAAQQiUSCZu9KYLwKAvNwmQx1rKc9nkRilu7tgkU1v+s+rvFy0WwEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAtMmJyM1JgfoT8r3ZR+NLWN+Agrqht+tgNMGzU9Iz8xiIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAxlO3H5RoGKlb3DnwkYRFvJA6CHa3OAYOnl2x3Owwq99U4LXxeFc/URnecapjrRm0SeO8tlRjk2yLrupNkXOSuQH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIbAJIMEUCIQDsGpZ4mf2veODasf9WfPMDfAyj0bsibyruw/3wp9KZ1wIgEd03O0yLset9ECQlIO/HL4TtSfdvQfvwh02nRuOgY6gBIQLIF7t1Ia/DXqlvO/snDm61Dd/6VWBie5Yf7ADymWUIvwEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIbAJIMEUCIQDelwGo+8K1FHCnn5V0LTz/267tYvzpJKCg1dcFYFFTxQIgRd8PiHo5I7pLMWKTtgzZ/xAdiZUqfbBpxHlWMzJ8PKIBIQL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AEOILzUhacJyyXRNGOhgy2yGUxsnZ/nK5aZ9P5CyCvtk9MmAQ8EAAAAAAEQBP7///8AAQMIGHMBAAAAAAABBCJRIJm70pgvAoC83CZDHWspz2eRGKW7u2CRTW/6z6u8XLRbAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==" + }, + "supplementary": { + "hex": "70736274ff010204020000000104010201050101010601002207027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682102d3262723352607e84fcaf7651f8d2d637e020aea86dfad80d306cd4f48cfcc622208027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840c653b71f946818a95bdc39f0918445bc903a0876b738060e9e5db1dcec30abdf54e0b5f178573f5119de71aa63ad19b449e3bcb65463936c8baeea4d917392b901fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100ec1a967899fdaf78e0dab1ff567cf3037c0ca3d1bb226f2aeec3fdf0a7d299d7022011dd373b4c8bb1eb7d10242520efc72f84ed49f76f41fbf0874da746e3a063a801220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff0001011fa086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e220202f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc483045022100de9701a8fbc2b51470a79f95742d3cffdbaeed62fce924a0a0d5d705605153c5022045df0f887a3923ba4b316293b60cd9ff101d89952a7db069c4795633327c3ca201220602f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc080000008001000000010e20bcd485a709cb25d13463a1832db2194c6c9d9fe72b9699f4fe42c82bed93d326010f0400000000011004feffffff000103081873010000000000010422512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "295c2eedddd8331d20b5d4cf9e69bb523ed85cb0bf35ab12e04fea66fe6d4a4a", + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "prevout_txid": "26d393ed2bc842fef499962be79f9d6c4c19b22d83a16334d125cb09a785d4bc", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e00000000", + "witness_utxo": "a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "02d3262723352607e84fcaf7651f8d2d637e020aea86dfad80d306cd4f48cfcc62", + "dleq_proof": "c653b71f946818a95bdc39f0918445bc903a0876b738060e9e5db1dcec30abdf54e0b5f178573f5119de71aa63ad19b449e3bcb65463936c8baeea4d917392b9" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two inputs single-signer using per-input ECDH shares", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQDsGpZ4mf2veODasf9WfPMDfAyj0bsibyruw/3wp9KZ1wIgEd03O0yLset9ECQlIO/HL4TtSfdvQfvwh02nRuOgY6gBIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAR+ghgEAAAAAABYAFKaSURwHlXW/N1bavFatcdQoSmkOIgIC9bWfpeSSIh6/Vbp4rUQmBb6ulRZroeujJQ0Luqx+LtxIMEUCIQDelwGo+8K1FHCnn5V0LTz/267tYvzpJKCg1dcFYFFTxQIgRd8PiHo5I7pLMWKTtgzZ/xAdiZUqfbBpxHlWMzJ8PKIBAQMEAQAAACIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cCAAAAIABAAAAAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQM00s73Tt7URkInYH/FmsHegMEqJDOlYnFSjtzPUPpsKyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQDfADAtCoHP2tl8MS25W4Gd0s4DB3z3ii2QLEh7gs7TPeFDfRW4LXY4Zdd3/JSYsg4HiD4Us2HC94/aoMqYyW8wAAQMIGHMBAAAAAAABBCJRIJm70pgvAoC83CZDHWspz2eRGKW7u2CRTW/6z6u8XLRbAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAOwalniZ/a944Nqx/1Z88wN8DKPRuyJvKu7D/fCn0pnXAiAR3Tc7TIux630QJCUg78cvhO1J929B+/CHTadG46BjqAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIbAJIMEUCIQDelwGo+8K1FHCnn5V0LTz/267tYvzpJKCg1dcFYFFTxQIgRd8PiHo5I7pLMWKTtgzZ/xAdiZUqfbBpxHlWMzJ8PKIBIQL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AEOILzUhacJyyXRNGOhgy2yGUxsnZ/nK5aZ9P5CyCvtk9MmAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCEDNNLO907e1EZCJ2B/xZrB3oDBKiQzpWJxUo7cz1D6bCsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaEA3wAwLQqBz9rZfDEtuVuBndLOAwd894otkCxIe4LO0z3hQ30VuC12OGXXd/yUmLIOB4g+FLNhwveP2qDKmMlvMAAEDCBhzAQAAAAAAAQQiUSCZu9KYLwKAvNwmQx1rKc9nkRilu7tgkU1v+s+rvFy0WwEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100ec1a967899fdaf78e0dab1ff567cf3037c0ca3d1bb226f2aeec3fdf0a7d299d7022011dd373b4c8bb1eb7d10242520efc72f84ed49f76f41fbf0874da746e3a063a801220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001011fa086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e220202f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc483045022100de9701a8fbc2b51470a79f95742d3cffdbaeed62fce924a0a0d5d705605153c5022045df0f887a3923ba4b316293b60cd9ff101d89952a7db069c4795633327c3ca20101030401000000220602f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc080000008001000000010e20bcd485a709cb25d13463a1832db2194c6c9d9fe72b9699f4fe42c82bed93d326010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068210334d2cef74eded4464227607fc59ac1de80c12a2433a56271528edccf50fa6c2b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0684037c00c0b42a073f6b65f0c4b6e56e06774b380c1df3de28b640b121ee0b3b4cf7850df456e0b5d8e1975ddff25262c8381e20f852cd870bde3f6a832a6325bcc000103081873010000000000010422512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "295c2eedddd8331d20b5d4cf9e69bb523ed85cb0bf35ab12e04fea66fe6d4a4a", + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "prevout_txid": "26d393ed2bc842fef499962be79f9d6c4c19b22d83a16334d125cb09a785d4bc", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e00000000", + "witness_utxo": "a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + }, + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "0334d2cef74eded4464227607fc59ac1de80c12a2433a56271528edccf50fa6c2b", + "dleq_proof": "37c00c0b42a073f6b65f0c4b6e56e06774b380c1df3de28b640b121ee0b3b4cf7850df456e0b5d8e1975ddff25262c8381e20f852cd870bde3f6a832a6325bcc", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two inputs / two sp outputs with mixed global and per-input ECDH shares", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQIBBgEAIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghA2bPx/3OBuCO1JsbOVK40VGo9+B1/l9t1Y3Wj52t7sqUIggDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAXquLCG1IUP6dHJ+WGpH5l7YcqNCFCvwGp4vfPHSe9UBQ5pK1P7WwhuXnh5PwHnbTdH+J4xd6f+/2+MFhfxsG4wH7BAIAAAAAAQEfQA0DAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/RzBEAiAKK+ZG0anqXBVNlCNCmskJl9/09NFCJp/mC8dvxE42HAIgCANa6s/ngmX6X6JTanzM6oXez4bcGYlSGOAMQI1gw7ABAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g/S309Ytav5uR/xoeQ+LjUj9QxqoZ1cIjYBQexIyagCEBDwQAAAAAARAE/v///yIdAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQIQP70XPZxI1YxQIkJtBSeLyhe5qOIoJmaQGhsAueBLeZSSIeAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQQMBdpBBIfPrsN4/r5q9QBeOubIYjaBiw5VshQBfrUHPt70AXlXW13NqpBjSRrIuD/QYk1Bd6TS3UmUxGQNa4zN4AAQEfQA0DAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDiICAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cSDBFAiEA1c3ZMOY2lwfrZ4b1q8L00OgVt4cmVi2tA1VpGbbQIjgCIF8zRs9QoCxciaScoUlqFfUE49+mFdDTyCBi0nGS0uE5AQEDBAEAAAAiBgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AgAAACAAQAAAAEOIITULym/Ww9KyMHgbIoBNLUz+CwKAffuThNSpATHWvsuAQ8EAAAAAAEQBP7///8iHQKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVECEDpqibG5hqmVUz4XvtZFALVBuw1zkHHv4q4rfvsKDKa88iHgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEEDDSmopQLvppzVsHMb/41jdREHbWIl8upnCEut1KF59oeyhHHksl6OASTNFqyJN6dlMKzbuhSauI1KBcaMjHeczAAEDCJBfAQAAAAAAAQQiUSCxKAm+EU5RY5SZU7O++G4xbRcMZzZlTdRqkb2+RLxVEAEJQgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKAMSZlgePoQcu5TeYupzVYOiMsTIiPpu3vLsL4cHifwd1AABAwiQXwEAAAAAAAEEIlEge2sCToSJVp8gv7oB/byYmecZMBVcHiDoeJIGlPmxpggBCUICqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRACSkjXbiDUC89fLhpcP/6z3CqLO4jXmkhtVMnZ6qj6GI4A", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQIBBgEAIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghA2bPx/3OBuCO1JsbOVK40VGo9+B1/l9t1Y3Wj52t7sqUIggDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAXquLCG1IUP6dHJ+WGpH5l7YcqNCFCvwGp4vfPHSe9UBQ5pK1P7WwhuXnh5PwHnbTdH+J4xd6f+/2+MFhfxsG4wH7BAIAAAAAAQEfQA0DAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIawJHMEQCIAor5kbRqepcFU2UI0KayQmX3/T00UImn+YLx2/ETjYcAiAIA1rqz+eCZfpfolNqfMzqhd7PhtwZiVIY4AxAjWDDsAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g/S309Ytav5uR/xoeQ+LjUj9QxqoZ1cIjYBQexIyagCEBDwQAAAAAARAE/v///yIdAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQIQP70XPZxI1YxQIkJtBSeLyhe5qOIoJmaQGhsAueBLeZSSIeAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQQMBdpBBIfPrsN4/r5q9QBeOubIYjaBiw5VshQBfrUHPt70AXlXW13NqpBjSRrIuD/QYk1Bd6TS3UmUxGQNa4zN4AAQEfQA0DAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIbAJIMEUCIQDVzdkw5jaXB+tnhvWrwvTQ6BW3hyZWLa0DVWkZttAiOAIgXzNGz1CgLFyJpJyhSWoV9QTj36YV0NPIIGLScZLS4TkBIQL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AEOIITULym/Ww9KyMHgbIoBNLUz+CwKAffuThNSpATHWvsuAQ8EAAAAAAEQBP7///8iHQKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVECEDpqibG5hqmVUz4XvtZFALVBuw1zkHHv4q4rfvsKDKa88iHgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEEDDSmopQLvppzVsHMb/41jdREHbWIl8upnCEut1KF59oeyhHHksl6OASTNFqyJN6dlMKzbuhSauI1KBcaMjHeczAAEDCJBfAQAAAAAAAQQiUSCxKAm+EU5RY5SZU7O++G4xbRcMZzZlTdRqkb2+RLxVEAEJQgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKAMSZlgePoQcu5TeYupzVYOiMsTIiPpu3vLsL4cHifwd1AABAwiQXwEAAAAAAAEEIlEge2sCToSJVp8gv7oB/byYmecZMBVcHiDoeJIGlPmxpggBCUICqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRACSkjXbiDUC89fLhpcP/6z3CqLO4jXmkhtVMnZ6qj6GI4A" + }, + "supplementary": { + "hex": "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", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "21809a8cc41e146023c2d519aac6503f52e3e2431e1aff919bbf5a8bf5f42dfd", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01400d0300000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "400d0300000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "295c2eedddd8331d20b5d4cf9e69bb523ed85cb0bf35ab12e04fea66fe6d4a4a", + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "prevout_txid": "2efb5ac704a452134eeef7010a2cf833b534018a6ce0c1c84a0f5bbf292fd484", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01400d030000000000160014a692511c079575bf3756dabc56ad71d4284a690e00000000", + "witness_utxo": "400d030000000000160014a692511c079575bf3756dabc56ad71d4284a690e", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "0366cfc7fdce06e08ed49b1b3952b8d151a8f7e075fe5f6dd58dd68f9dadeeca94", + "dleq_proof": "5eab8b086d4850fe9d1c9f961a91f997b61ca8d0850afc06a78bdf3c749ef54050e692b53fb5b086e5e78793f01e76d3747f89e3177a7feff6f8c1617f1b06e3" + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "03fbd173d9c48d58c5022426d05278bca17b9a8e2282666901a1b00b9e04b79949", + "dleq_proof": "c05da410487cfaec378febe6af5005e3ae6c86236818b0e55b214017eb5073edef40179575b5dcdaa9063491ac8b83fd0624d4177a4d2dd4994c4640d6b8ccde", + "input_index": 0 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "03a6a89b1b986a995533e17bed64500b541bb0d739071efe2ae2b7efb0a0ca6bcf", + "dleq_proof": "c34a6a2940bbe9a7356c1cc6ffe358dd4441db58897cba99c212eb75285e7da1eca11c792c97a380493345ab224de9d94c2b36ee8526ae23528171a3231de733", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd4", + "script": "5120b12809be114e5163949953b3bef86e316d170c6736654dd46a91bdbe44bc5510" + }, + { + "output_index": 1, + "amount": 90000, + "sp_v0_info": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e", + "script": "51207b6b024e8489569f20bfba01fdbc9899e71930155c1e20e878920694f9b1a608" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: one input / one sp output with both global and per-input ECDH shares", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghAwoYubtBmbiTMOsX+O5ax4bghT3NLzzN8XRLl85O3gU+IggDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAJ/uQxdYceOMRUgD/0YPSjQq0g4BiyVQZNMZBbUJnzjG9QofpNZRSwIF68O9NUM/1eENrDSj57Y8ht5pEdkCAjgH7BAIAAAAAAQEfQA0DAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/SDBFAiEAyFvlr5bhqKf1YcXDSFBg36YAz/htqrTzO6OY5lBittkCIBPq0/BHmz/uJrpIh+BRh2ZjzRP8fmHmDS6WBkIym0HkAQEDBAEAAAAiBgLIF7t1Ia/DXqlvO/snDm61Dd/6VWBie5Yf7ADymWUIvwgAAACAAAAAAAEOIP0t9PWLWr+bkf8aHkPi41I/UMaqGdXCI2AUHsSMmoAhAQ8EAAAAAAEQBP7///8iHQMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKCEDChi5u0GZuJMw6xf47lrHhuCFPc0vPM3xdEuXzk7eBT4iHgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKEAAE4PUZhvocl7ykEj0jJEfifXzQxfXwMCsxg72XxtSv/96ltgzm2Jd+Dq6tXqic+3NmjXHlNrLschhFxuyZwdfAAEDCJBfAQAAAAAAAQQiUSAqcL4BPYeh6B6gH736DPH/CNUqaNGMExqMyWAfhKagrAEJQgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKAMSZlgePoQcu5TeYupzVYOiMsTIiPpu3vLsL4cHifwd1AA=", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghAwoYubtBmbiTMOsX+O5ax4bghT3NLzzN8XRLl85O3gU+IggDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAJ/uQxdYceOMRUgD/0YPSjQq0g4BiyVQZNMZBbUJnzjG9QofpNZRSwIF68O9NUM/1eENrDSj57Y8ht5pEdkCAjgH7BAIAAAAAAQEfQA0DAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIbAJIMEUCIQDIW+WvluGop/VhxcNIUGDfpgDP+G2qtPM7o5jmUGK22QIgE+rT8EebP+4mukiH4FGHZmPNE/x+YeYNLpYGQjKbQeQBIQLIF7t1Ia/DXqlvO/snDm61Dd/6VWBie5Yf7ADymWUIvwEOIP0t9PWLWr+bkf8aHkPi41I/UMaqGdXCI2AUHsSMmoAhAQ8EAAAAAAEQBP7///8iHQMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKCEDChi5u0GZuJMw6xf47lrHhuCFPc0vPM3xdEuXzk7eBT4iHgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKEAAE4PUZhvocl7ykEj0jJEfifXzQxfXwMCsxg72XxtSv/96ltgzm2Jd+Dq6tXqic+3NmjXHlNrLschhFxuyZwdfAAEDCJBfAQAAAAAAAQQiUSAqcL4BPYeh6B6gH736DPH/CNUqaNGMExqMyWAfhKagrAEJQgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKAMSZlgePoQcu5TeYupzVYOiMsTIiPpu3vLsL4cHifwd1AA=" + }, + "supplementary": { + "hex": "70736274ff010204020000000104010101050101010601002207033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821030a18b9bb4199b89330eb17f8ee5ac786e0853dcd2f3ccdf1744b97ce4ede053e2208033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d284027fb90c5d61c78e3115200ffd183d28d0ab4838062c9541934c6416d4267ce31bd4287e9359452c0817af0ef4d50cff578436b0d28f9ed8f21b79a447640808e01fb04020000000001011f400d0300000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100c85be5af96e1a8a7f561c5c3485060dfa600cff86daab4f33ba398e65062b6d9022013ead3f0479b3fee26ba4887e051876663cd13fc7e61e60d2e960642329b41e40101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20fd2df4f58b5abf9b91ff1a1e43e2e3523f50c6aa19d5c22360141ec48c9a8021010f0400000000011004feffffff221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821030a18b9bb4199b89330eb17f8ee5ac786e0853dcd2f3ccdf1744b97ce4ede053e221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840001383d4661be8725ef29048f48c911f89f5f34317d7c0c0acc60ef65f1b52bfff7a96d8339b625df83abab57aa273edcd9a35c794dacbb1c861171bb267075f00010308905f01000000000001042251202a70be013d87a1e81ea01fbdfa0cf1ff08d52a68d18c131a8cc9601f84a6a0ac010942033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd400", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "21809a8cc41e146023c2d519aac6503f52e3e2431e1aff919bbf5a8bf5f42dfd", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01400d0300000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "400d0300000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "030a18b9bb4199b89330eb17f8ee5ac786e0853dcd2f3ccdf1744b97ce4ede053e", + "dleq_proof": "27fb90c5d61c78e3115200ffd183d28d0ab4838062c9541934c6416d4267ce31bd4287e9359452c0817af0ef4d50cff578436b0d28f9ed8f21b79a447640808e" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd4", + "script": "51202a70be013d87a1e81ea01fbdfa0cf1ff08d52a68d18c131a8cc9601f84a6a0ac" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: three sp outputs (different scan keys) with multiple global ECDH shares", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQMBBgEAIgcCqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRAhAsLZ32DuaaWoZgTdmmKCwi744sknbabllaVGPzcare4kIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghAtx9LsrFaLARUXW6PNVJb/TEttkJQi28yuuPJS+lT4vQIgcDjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwhAnC+9cBqmoVfxjv/K9C+LXADPIILYVNBPI1u2lHyWhspIggCqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRBA7IJCv3tYgc7gYFZsfxPMR+RxDImiZFjCAwGzAx5IFzvAvqAWgNM3XrXoBhGrDVCLHkmrtXGxh4AyquSfCwL30iIIAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oQOpDRw5eG+MpG0igvLU/VZUsZIYOdjXvulADzK3td90SjiFml7D1I74hfsaHUHeXzM68XNlDYq8bRtgDZCvV+UAiCAOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobEAb3+VO1KKgb/+bAAmuTj2A/EdhZHWv3yEkTP48bRBN8kdBqHVRTXhlT7nKERjm0+VS84+Mq6NVLoMzxQG/DL0/AfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQC42QsRZqzXY8+uqHOJGaBPRdBVbSvLD2Z/C6PEGO5f2QIgI64RGn6itGrUpKOIKuT++973rl0BtM22H1aXmv9SahgBIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiDUQOda/N1TGlkeN6vSbkryvw9v8uGRgwI1Yej8VxOPSgEPBAAAAAABEAT+////AAEBH6CGAQAAAAAAFgAUNyH6c8IwXLL4joSJLWvWuXcmHmoiAgJDoNQOneCIJ5QWF1K65CupCVJ4QgnwY0MPCvJWNUqFu0gwRQIhAJfXTGL5WdOu1bnHpXDy1zyq0MCrseRy1E/UxirCYuS5AiAX2VXEZF+Fr+z2aKPQRlXWdZPyNXYrGm9SKYcXYECqoAEiBgJDoNQOneCIJ5QWF1K65CupCVJ4QgnwY0MPCvJWNUqFuwgAAACAAQAAAAEOIOdsAXEIOkxftK/i9tYfAKRzAbnQH40uR3gKt1QuN3wIAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABBCJRIE6KUf3Rq9Uk/FLWkolTgu5u3MSNN3228eZRXyNALkgnAQlCAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oAxJmWB4+hBy7lN5i6nNVg6IyxMiI+m7e8uwvhweJ/B3UAAEDCJBfAQAAAAAAAQQiUSB+MV8kXPlXXxNDwxcP/O42rUbTO1ZfCji5lDx8AqzXawEJQgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEAJKSNduINQLz18uGlw//rPcKos7iNeaSG1UydnqqPoYjgABAwiQXwEAAAAAAAEEIlEgPK1PnUbiURy2iCuvYOjtgGIgsUFRPWkE2s0r6qE3w5UBCUIDjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwD+BRzhEyddMkh/xelr0ELYzc0jXr7/3OJG8XLDLJMsMAA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQMBBgEAIgcCqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRAhAsLZ32DuaaWoZgTdmmKCwi744sknbabllaVGPzcare4kIgcDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghAtx9LsrFaLARUXW6PNVJb/TEttkJQi28yuuPJS+lT4vQIgcDjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwhAnC+9cBqmoVfxjv/K9C+LXADPIILYVNBPI1u2lHyWhspIggCqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRBA7IJCv3tYgc7gYFZsfxPMR+RxDImiZFjCAwGzAx5IFzvAvqAWgNM3XrXoBhGrDVCLHkmrtXGxh4AyquSfCwL30iIIAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oQOpDRw5eG+MpG0igvLU/VZUsZIYOdjXvulADzK3td90SjiFml7D1I74hfsaHUHeXzM68XNlDYq8bRtgDZCvV+UAiCAOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobEAb3+VO1KKgb/+bAAmuTj2A/EdhZHWv3yEkTP48bRBN8kdBqHVRTXhlT7nKERjm0+VS84+Mq6NVLoMzxQG/DL0/AfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhALjZCxFmrNdjz66oc4kZoE9F0FVtK8sPZn8Lo8QY7l/ZAiAjrhEafqK0atSko4gq5P773veuXQG0zbYfVpea/1JqGAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g1EDnWvzdUxpZHjer0m5K8r8Pb/LhkYMCNWHo/FcTj0oBDwQAAAAAARAE/v///wABAR+ghgEAAAAAABYAFDch+nPCMFyy+I6EiS1r1rl3Jh5qAQhsAkgwRQIhAJfXTGL5WdOu1bnHpXDy1zyq0MCrseRy1E/UxirCYuS5AiAX2VXEZF+Fr+z2aKPQRlXWdZPyNXYrGm9SKYcXYECqoAEhAkOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7AQ4g52wBcQg6TF+0r+L21h8ApHMBudAfjS5HeAq3VC43fAgBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgTopR/dGr1ST8UtaSiVOC7m7cxI03fbbx5lFfI0AuSCcBCUIDM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSgDEmZYHj6EHLuU3mLqc1WDojLEyIj6bt7y7C+HB4n8HdQAAQMIkF8BAAAAAAABBCJRIH4xXyRc+VdfE0PDFw/87jatRtM7Vl8KOLmUPHwCrNdrAQlCAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQAkpI124g1AvPXy4aXD/+s9wqizuI15pIbVTJ2eqo+hiOAAEDCJBfAQAAAAAAAQQiUSA8rU+dRuJRHLaIK69g6O2AYiCxQVE9aQTazSvqoTfDlQEJQgOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobAP4FHOETJ10ySH/F6WvQQtjNzSNevv/c4kbxcsMskywwAA=" + }, + "supplementary": { + "hex": "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", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "4a8f1357fce86135028391e1f26f0fbff24a6ed2ab371e591a53ddfc5ae740d4", + "prevout_index": 0, + "amount": 500000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff0120a10700000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "20a10700000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "087c372e54b70a78472e8d1fd0b90173a4001fd6f6e2afb45f4c3a0871016ce7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "02dc7d2ecac568b0115175ba3cd5496ff4c4b6d909422dbccaeb8f252fa54f8bd0", + "dleq_proof": "ea43470e5e1be3291b48a0bcb53f55952c64860e7635efba5003ccaded77dd128e216697b0f523be217ec687507797cccebc5cd94362af1b46d803642bd5f940" + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02c2d9df60ee69a5a86604dd9a6282c22ef8e2c9276da6e595a5463f371aadee24", + "dleq_proof": "ec8242bf7b5881cee060566c7f13cc47e4710c89a26458c20301b3031e48173bc0bea01680d3375eb5e80611ab0d508b1e49abb571b1878032aae49f0b02f7d2" + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "0270bef5c06a9a855fc63bff2bd0be2d70033c820b6153413c8d6eda51f25a1b29", + "dleq_proof": "1bdfe54ed4a2a06fff9b0009ae4e3d80fc47616475afdf21244cfe3c6d104df24741a875514d78654fb9ca1118e6d3e552f38f8caba3552e8333c501bf0cbd3f" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd4", + "script": "51204e8a51fdd1abd524fc52d692895382ee6edcc48d377db6f1e6515f23402e4827" + }, + { + "output_index": 1, + "amount": 90000, + "sp_v0_info": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e", + "script": "51207e315f245cf9575f1343c3170ffcee36ad46d33b565f0a38b9943c7c02acd76b" + }, + { + "output_index": 2, + "amount": 90000, + "sp_v0_info": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c03f81473844c9d74c921ff17a5af410b6337348d7afbff73891bc5cb0cb24cb0c0", + "script": "51203cad4f9d46e2511cb6882baf60e8ed806220b141513d6904dacd2beaa137c395" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: one P2WPKH input / two mixed outputs - labeled sp output and BIP 32 change", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCPK7BV068xhdltYVI7x1UGydVRKIUnGQwguF9HPd5W8gIgZ0ErvfZD1lcvsUUFisMo7xFFAZvsjC9aImux76km008BAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g1EDnWvzdUxpZHjer0m5K8r8Pb/LhkYMCNWHo/FcTj0oBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIoIYBAAAAAAABBCJRILLXUKYOxNBb0sIicfCP4hsA4nEdOCMEi7lloivEFz0vAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA+qPIovitxbaze/LKBAHKHTwCkdvXAe9BRkXEmzGSz3vAQoEAQAAAAAiAgNelfRXHtom4PY2PqXFlHlK1N0hXqEmYvE8mpkG1aqTrgwAAAAAAAAAAAAAAAEBAwhw8wUAAAAAAAEEFgAU10OzS4cowqNfapTI2vQRh0WtlpsA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAI8rsFXTrzGF2W1hUjvHVQbJ1VEohScZDCC4X0c93lbyAiBnQSu99kPWVy+xRQWKwyjvEUUBm+yML1oia7HvqSbTTwEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g1EDnWvzdUxpZHjer0m5K8r8Pb/LhkYMCNWHo/FcTj0oBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQMIoIYBAAAAAAABBCJRILLXUKYOxNBb0sIicfCP4hsA4nEdOCMEi7lloivEFz0vAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA+qPIovitxbaze/LKBAHKHTwCkdvXAe9BRkXEmzGSz3vAQoEAQAAAAAiAgNelfRXHtom4PY2PqXFlHlK1N0hXqEmYvE8mpkG1aqTrgwAAAAAAAAAAAAAAAEBAwhw8wUAAAAAAAEEFgAU10OzS4cowqNfapTI2vQRh0WtlpsA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501020106010001fb04020000000001011f20a10700000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf4830450221008f2bb055d3af3185d96d61523bc75506c9d551288527190c20b85f473dde56f2022067412bbdf643d6572fb145058ac328ef1145019bec8c2f5a226bb1efa926d34f0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20d440e75afcdd531a591e37abd26e4af2bf0f6ff2e19183023561e8fc57138f4a010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308a0860100000000000104225120b2d750a60ec4d05bd2c22271f08fe21b00e2711d3823048bb965a22bc4173d2f010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06803ea8f228be2b716dacdefcb2810072874f00a476f5c07bd051917126cc64b3def010a0401000000002202035e95f4571eda26e0f6363ea5c594794ad4dd215ea12662f13c9a9906d5aa93ae0c00000000000000000000000101030870f30500000000000104160014d743b34b8728c2a35f6a94c8daf4118745ad969b00", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "4a8f1357fce86135028391e1f26f0fbff24a6ed2ab371e591a53ddfc5ae740d4", + "prevout_index": 0, + "amount": 500000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff0120a10700000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "20a10700000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06803ea8f228be2b716dacdefcb2810072874f00a476f5c07bd051917126cc64b3def", + "sp_v0_label": 1, + "script": "5120b2d750a60ec4d05bd2c22271f08fe21b00e2711d3823048bb965a22bc4173d2f" + }, + { + "output_index": 1, + "amount": 390000, + "script": "0014d743b34b8728c2a35f6a94c8daf4118745ad969b" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: one input / two sp outputs - output 0 has no label / output 1 uses label=0 convention for sp change", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR/gkwQAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIFB2CeL9erskEbcJ/ZjL+pgC0nxcDrLBEMLU8/EJ61yYAiBeYmSIxVqzZbFYt+8gUlTszHEFFvbNOzksUNGJgWmDsQEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiDXHS3QFsrGYSyer5hVH2eAhRu3czlByBTq+trO3jDcPQEPBAAAAAABEAT+////Ih0CXw7Bs42ZhKfrYvFb5AMCBBDxQu301p42P1YVr9Kmts0hA84eNnXZDZkmSfqd2xH5AlSbs7AvVvbonMCgTIuMN92UIh0Ci3kOCYf96fDRI5jra+MMc3Z5PGR4ZaKgLy78lg2WZWghAlWBv6pzMVb2uY5xom9w/XazZ4ZJ9isfxed7jpq45hBQIh4CXw7Bs42ZhKfrYvFb5AMCBBDxQu301p42P1YVr9Kmts1ADolhPR9rJTbbj6kkIA2zpvjvyhciVWTVaxEuUIZbTTAuBY+m9hwp4jZqSnJp1FVaXGHWVVnb+/rJ4urf5TY31SIeAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoQHlAgZ626fJYwVg4fApkzBb1F8fvRAkSLM6qlPTi/1N2xCR7/BcNmyY7Dj0ga2aMh+lLNN7q+gCheSsEeteIdbsAAQMIoIYBAAAAAAABBCJRIBM/6m8cjln0UbKW1K2xPs7sf8M9vFNq5NY3WropOE+LAQlCAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoA7RDRzNcY/UF5V4mirKA8xi0pqoUSS/zecNmih9U74ybAAEDCDDmAgAAAAAAAQQiUSBgK8NLBuQ1Rvh+VIKxETqr+cn+KSUJmpItXCPYS7zqxgEJQgJfDsGzjZmEp+ti8VvkAwIEEPFC7fTWnjY/VhWv0qa2zQLOCzIZpapd+PIc45PpYs3afVFUbaTTXDjtAYilludg8wEKBAAAAAAA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR/gkwQAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhrAkcwRAIgUHYJ4v16uyQRtwn9mMv6mALSfFwOssEQwtTz8QnrXJgCIF5iZIjFWrNlsVi37yBSVOzMcQUW9s07OSxQ0YmBaYOxASECyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8BDiDXHS3QFsrGYSyer5hVH2eAhRu3czlByBTq+trO3jDcPQEPBAAAAAABEAT+////Ih0CXw7Bs42ZhKfrYvFb5AMCBBDxQu301p42P1YVr9Kmts0hA84eNnXZDZkmSfqd2xH5AlSbs7AvVvbonMCgTIuMN92UIh0Ci3kOCYf96fDRI5jra+MMc3Z5PGR4ZaKgLy78lg2WZWghAlWBv6pzMVb2uY5xom9w/XazZ4ZJ9isfxed7jpq45hBQIh4CXw7Bs42ZhKfrYvFb5AMCBBDxQu301p42P1YVr9Kmts1ADolhPR9rJTbbj6kkIA2zpvjvyhciVWTVaxEuUIZbTTAuBY+m9hwp4jZqSnJp1FVaXGHWVVnb+/rJ4urf5TY31SIeAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoQHlAgZ626fJYwVg4fApkzBb1F8fvRAkSLM6qlPTi/1N2xCR7/BcNmyY7Dj0ga2aMh+lLNN7q+gCheSsEeteIdbsAAQMIoIYBAAAAAAABBCJRIBM/6m8cjln0UbKW1K2xPs7sf8M9vFNq5NY3WropOE+LAQlCAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoA7RDRzNcY/UF5V4mirKA8xi0pqoUSS/zecNmih9U74ybAAEDCDDmAgAAAAAAAQQiUSBgK8NLBuQ1Rvh+VIKxETqr+cn+KSUJmpItXCPYS7zqxgEJQgJfDsGzjZmEp+ti8VvkAwIEEPFC7fTWnjY/VhWv0qa2zQLOCzIZpapd+PIc45PpYs3afVFUbaTTXDjtAYilludg8wEKBAAAAAAA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501020106010001fb04020000000001011fe0930400000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf4730440220507609e2fd7abb2411b709fd98cbfa9802d27c5c0eb2c110c2d4f3f109eb5c9802205e626488c55ab365b158b7ef205254eccc710516f6cd3b392c50d189816983b10101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20d71d2dd016cac6612c9eaf98551f6780851bb7733941c814eafadacede30dc3d010f0400000000011004feffffff221d025f0ec1b38d9984a7eb62f15be403020410f142edf4d69e363f5615afd2a6b6cd2103ce1e3675d90d992649fa9ddb11f902549bb3b02f56f6e89cc0a04c8b8c37dd94221d028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656821025581bfaa733156f6b98e71a26f70fd76b3678649f62b1fc5e77b8e9ab8e61050221e025f0ec1b38d9984a7eb62f15be403020410f142edf4d69e363f5615afd2a6b6cd400e89613d1f6b2536db8fa924200db3a6f8efca17225564d56b112e50865b4d302e058fa6f61c29e2366a4a7269d4555a5c61d65559dbfbfac9e2eadfe53637d5221e028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568407940819eb6e9f258c158387c0a64cc16f517c7ef4409122cceaa94f4e2ff5376c4247bfc170d9b263b0e3d206b668c87e94b34deeafa00a1792b047ad78875bb00010308a0860100000000000104225120133fea6f1c8e59f451b296d4adb13eceec7fc33dbc536ae4d6375aba29384f8b010942028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656803b44347335c63f505e55e268ab280f318b4a6aa14492ff379c3668a1f54ef8c9b0001030830e60200000000000104225120602bc34b06e43546f87e5482b1113aabf9c9fe2925099a922d5c23d84bbceac6010942025f0ec1b38d9984a7eb62f15be403020410f142edf4d69e363f5615afd2a6b6cd02ce0b3219a5aa5df8f21ce393e962cdda7d51546da4d35c38ed0188a596e760f3010a040000000000", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "3ddc30decedafaea14c8413973b71b8580671f5598af9e2c61c6ca16d02d1dd7", + "prevout_index": 0, + "amount": 300000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01e0930400000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "e0930400000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "025f0ec1b38d9984a7eb62f15be403020410f142edf4d69e363f5615afd2a6b6cd", + "ecdh_share": "03ce1e3675d90d992649fa9ddb11f902549bb3b02f56f6e89cc0a04c8b8c37dd94", + "dleq_proof": "0e89613d1f6b2536db8fa924200db3a6f8efca17225564d56b112e50865b4d302e058fa6f61c29e2366a4a7269d4555a5c61d65559dbfbfac9e2eadfe53637d5", + "input_index": 0 + }, + { + "scan_key": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568", + "ecdh_share": "025581bfaa733156f6b98e71a26f70fd76b3678649f62b1fc5e77b8e9ab8e61050", + "dleq_proof": "7940819eb6e9f258c158387c0a64cc16f517c7ef4409122cceaa94f4e2ff5376c4247bfc170d9b263b0e3d206b668c87e94b34deeafa00a1792b047ad78875bb", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 100000, + "sp_v0_info": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656803b44347335c63f505e55e268ab280f318b4a6aa14492ff379c3668a1f54ef8c9b", + "script": "5120133fea6f1c8e59f451b296d4adb13eceec7fc33dbc536ae4d6375aba29384f8b" + }, + { + "output_index": 1, + "amount": 190000, + "sp_v0_info": "025f0ec1b38d9984a7eb62f15be403020410f142edf4d69e363f5615afd2a6b6cd02ce0b3219a5aa5df8f21ce393e962cdda7d51546da4d35c38ed0188a596e760f3", + "sp_v0_label": 0, + "script": "5120602bc34b06e43546f87e5482b1113aabf9c9fe2925099a922d5c23d84bbceac6" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: three sp outputs (same scan key) - output 0 uses label=1, outputs 1 and 2 uses label=2 (same spend key)", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQMBBgEAAfsEAgAAAAABAR+AGgYAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCUWfs0hcwTRkOekp3AdPHTla2+gwarlNndhIFCaNDsOAIgOAjuJjqIA6Fy5rMVCyyiJMlhF6GfDplTlH+lICupcGUBAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4gcOBrhlWVxMJzHTP1pq0oD7hwNVRmYpiAyl3NjpAH4ZoBDwQAAAAAARAE/v///yIdAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoIQJVgb+qczFW9rmOcaJvcP12s2eGSfYrH8Xne46auOYQUCIeAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoQHlAgZ626fJYwVg4fApkzBb1F8fvRAkSLM6qlPTi/1N2xCR7/BcNmyY7Dj0ga2aMh+lLNN7q+gCheSsEeteIdbsAAQMIoYYBAAAAAAABBCJRIJPaXrkneTYjgSVQ+GmdZjtxlvDMnUiEWLtoH+srb/y6AQlCAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoA9QxWI3uYas6OXJbKZw3QtxmoIYd7PWRtCOw5ScHD4I0AQoEAQAAAAABAwgy5gIAAAAAAAEEIlEg/euuKHi5JCPRfXT0zBQOHpmABZeNccGDE5KAQF4w5AYBCUICi3kOCYf96fDRI5jra+MMc3Z5PGR4ZaKgLy78lg2WZWgDIZOtDIdfrFJDc4AikAp3JMYXXdrJlEFlqrRXqt+cTzwBCgQCAAAAAAEDCKKGAQAAAAAAAQQiUSD04wY25I9qev6YT6CyVFslfqroyqFuxIGT2zSJJpWHWwEJQgKLeQ4Jh/3p8NEjmOtr4wxzdnk8ZHhloqAvLvyWDZZlaAMhk60Mh1+sUkNzgCKQCnckxhdd2smUQWWqtFeq35xPPAEKBAIAAAAA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQMBBgEAAfsEAgAAAAABAR+AGgYAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAJRZ+zSFzBNGQ56SncB08dOVrb6DBquU2d2EgUJo0Ow4AiA4CO4mOogDoXLmsxULLKIkyWEXoZ8OmVOUf6UgK6lwZQEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4gcOBrhlWVxMJzHTP1pq0oD7hwNVRmYpiAyl3NjpAH4ZoBDwQAAAAAARAE/v///yIdAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoIQJVgb+qczFW9rmOcaJvcP12s2eGSfYrH8Xne46auOYQUCIeAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoQHlAgZ626fJYwVg4fApkzBb1F8fvRAkSLM6qlPTi/1N2xCR7/BcNmyY7Dj0ga2aMh+lLNN7q+gCheSsEeteIdbsAAQMIoYYBAAAAAAABBCJRIJPaXrkneTYjgSVQ+GmdZjtxlvDMnUiEWLtoH+srb/y6AQlCAot5DgmH/enw0SOY62vjDHN2eTxkeGWioC8u/JYNlmVoA9QxWI3uYas6OXJbKZw3QtxmoIYd7PWRtCOw5ScHD4I0AQoEAQAAAAABAwgy5gIAAAAAAAEEIlEg/euuKHi5JCPRfXT0zBQOHpmABZeNccGDE5KAQF4w5AYBCUICi3kOCYf96fDRI5jra+MMc3Z5PGR4ZaKgLy78lg2WZWgDIZOtDIdfrFJDc4AikAp3JMYXXdrJlEFlqrRXqt+cTzwBCgQCAAAAAAEDCKKGAQAAAAAAAQQiUSD04wY25I9qev6YT6CyVFslfqroyqFuxIGT2zSJJpWHWwEJQgKLeQ4Jh/3p8NEjmOtr4wxzdnk8ZHhloqAvLvyWDZZlaAMhk60Mh1+sUkNzgCKQCnckxhdd2smUQWWqtFeq35xPPAEKBAIAAAAA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501030106010001fb04020000000001011f801a0600000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf4830450221009459fb3485cc1346439e929dc074f1d395adbe8306ab94d9dd84814268d0ec3802203808ee263a8803a172e6b3150b2ca224c96117a19f0e9953947fa5202ba970650101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e2070e06b865595c4c2731d33f5a6ad280fb870355466629880ca5dcd8e9007e19a010f0400000000011004feffffff221d028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656821025581bfaa733156f6b98e71a26f70fd76b3678649f62b1fc5e77b8e9ab8e61050221e028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568407940819eb6e9f258c158387c0a64cc16f517c7ef4409122cceaa94f4e2ff5376c4247bfc170d9b263b0e3d206b668c87e94b34deeafa00a1792b047ad78875bb00010308a186010000000000010422512093da5eb927793623812550f8699d663b7196f0cc9d488458bb681feb2b6ffcba010942028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656803d431588dee61ab3a39725b299c3742dc66a0861decf591b423b0e527070f8234010a04010000000001030832e60200000000000104225120fdebae2878b92423d17d74f4cc140e1e998005978d71c183139280405e30e406010942028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568032193ad0c875fac5243738022900a7724c6175ddac9944165aab457aadf9c4f3c010a040200000000010308a2860100000000000104225120f4e30636e48f6a7afe984fa0b2545b257eaae8caa16ec48193db34892695875b010942028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568032193ad0c875fac5243738022900a7724c6175ddac9944165aab457aadf9c4f3c010a040200000000", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "9ae107908ecd5dca80986266543570b80f28ada6f5331d73c2c49555866be070", + "prevout_index": 0, + "amount": 400000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01801a0600000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "801a0600000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568", + "ecdh_share": "025581bfaa733156f6b98e71a26f70fd76b3678649f62b1fc5e77b8e9ab8e61050", + "dleq_proof": "7940819eb6e9f258c158387c0a64cc16f517c7ef4409122cceaa94f4e2ff5376c4247bfc170d9b263b0e3d206b668c87e94b34deeafa00a1792b047ad78875bb", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 100001, + "sp_v0_info": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d96656803d431588dee61ab3a39725b299c3742dc66a0861decf591b423b0e527070f8234", + "sp_v0_label": 1, + "script": "512093da5eb927793623812550f8699d663b7196f0cc9d488458bb681feb2b6ffcba" + }, + { + "output_index": 1, + "amount": 190002, + "sp_v0_info": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568032193ad0c875fac5243738022900a7724c6175ddac9944165aab457aadf9c4f3c", + "sp_v0_label": 2, + "script": "5120fdebae2878b92423d17d74f4cc140e1e998005978d71c183139280405e30e406" + }, + { + "output_index": 2, + "amount": 100002, + "sp_v0_info": "028b790e0987fde9f0d12398eb6be30c7376793c647865a2a02f2efc960d966568032193ad0c875fac5243738022900a7724c6175ddac9944165aab457aadf9c4f3c", + "sp_v0_label": 2, + "script": "5120f4e30636e48f6a7afe984fa0b2545b257eaae8caa16ec48193db34892695875b" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two inputs using per-input ECDH shares - only eligible inputs contribute shares (P2SH excluded)", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIHX/+DN7oavaEJzJjnIcVUgz9mY0VLyglR21zhcuA3LjAiAFXY5F4lr2Gu+QPcbwd9LpuW0Ut5Op7+w5K5bqn1Hf7gEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAFMCAAAAAUDm+qYSaPF6EBAdYlU1gogq5IWL7hM2PbgP3ygfgl/8AAAAAAD/////AfBJAgAAAAAAF6kU9F+MyiaOwm5LvomRcPE4JQ189V6HAAAAACICAod8oC8UQFm9gtAOGzma43T3ilLO96HKN/KNeIs0DS95SDBFAiEAqSSjxsVMq0LZrsVrZN4OgTZn7OqQUi0BVLG9SX4ez+YCIGft7MnVjKeYvO1u7T6P8a78F3wXYOtCur6uou2iCI3PASICA0yHpEhy9eHwBtNNiKAJWSgr1FNedHfD1owxZZkeobOWRzBEAiAFkbOcu2+fEK7M5arMpm9mZybWJUb4KIZG0kEVrZeVlQIgI77PzicSbG9Gn2gR0KGOTzipSLOk7Gg1PusWVdZmbOkBAQRHUiECh3ygLxRAWb2C0A4bOZrjdPeKUs73oco38o14izQNL3khA0yHpEhy9eHwBtNNiKAJWSgr1FNedHfD1owxZZkeobOWUq4BDiDSIiYvJocpu3yExVgSml1phhhc71NewUnA32DdSpLCBAEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAmKLaLZEbmqHAllz2Tr7GU5CChDzocyzit2C1GSolKQoIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwiQXwEAAAAAAAEEIlEgFlXRMkKnFHnfSR7Zw5s8dapbHNjQFr+Ms1SnTXd0Hd4BCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhrAkcwRAIgdf/4M3uhq9oQnMmOchxVSDP2ZjRUvKCVHbXOFy4DcuMCIAVdjkXiWvYa75A9xvB30um5bRS3k6nv7DkrluqfUd/uASECyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8BDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAFMCAAAAAUDm+qYSaPF6EBAdYlU1gogq5IWL7hM2PbgP3ygfgl/8AAAAAAD/////AfBJAgAAAAAAF6kU9F+MyiaOwm5LvomRcPE4JQ189V6HAAAAAAEH2gBIMEUCIQCpJKPGxUyrQtmuxWtk3g6BNmfs6pBSLQFUsb1Jfh7P5gIgZ+3sydWMp5i87W7tPo/xrvwXfBdg60K6vq6i7aIIjc8BRzBEAiAFkbOcu2+fEK7M5arMpm9mZybWJUb4KIZG0kEVrZeVlQIgI77PzicSbG9Gn2gR0KGOTzipSLOk7Gg1PusWVdZmbOkBR1IhAod8oC8UQFm9gtAOGzma43T3ilLO96HKN/KNeIs0DS95IQNMh6RIcvXh8AbTTYigCVkoK9RTXnR3w9aMMWWZHqGzllKuAQ4g0iImLyaHKbt8hMVYEppdaYYYXO9TXsFJwN9g3UqSwgQBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQJii2i2RG5qhwJZc9k6+xlOQgoQ86HMs4rdgtRkqJSkKCIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIkF8BAAAAAAABBCJRIBZV0TJCpxR530ke2cObPHWqWxzY0Ba/jLNUp013dB3eAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==" + }, + "supplementary": { + "hex": "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", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "", + "public_key": "", + "prevout_txid": "04c2924add60dfc049c15e53ef5c1886695d9a1258c5847cbb2987262f2622d2", + "prevout_index": 0, + "amount": 150000, + "non_witness_utxo": "020000000140e6faa61268f17a10101d62553582882ae4858bee13363db80fdf281f825ffc0000000000ffffffff01f04902000000000017a914f45f8cca268ec26e4bbe899170f138250d7cf55e8700000000", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51201655d13242a71479df491ed9c39b3c75aa5b1cd8d016bf8cb354a74d77741dde" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two inputs using global ECDH share - only eligible inputs contribute shares (P2SH excluded)", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/RzBEAiB1//gze6Gr2hCcyY5yHFVIM/ZmNFS8oJUdtc4XLgNy4wIgBV2OReJa9hrvkD3G8HfS6bltFLeTqe/sOSuW6p9R3+4BIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEAUwIAAAABQOb6phJo8XoQEB1iVTWCiCrkhYvuEzY9uA/fKB+CX/wAAAAAAP////8B8EkCAAAAAAAXqRT0X4zKJo7Cbku+iZFw8TglDXz1XocAAAAAIgICh3ygLxRAWb2C0A4bOZrjdPeKUs73oco38o14izQNL3lIMEUCIQCpJKPGxUyrQtmuxWtk3g6BNmfs6pBSLQFUsb1Jfh7P5gIgZ+3sydWMp5i87W7tPo/xrvwXfBdg60K6vq6i7aIIjc8BIgIDTIekSHL14fAG002IoAlZKCvUU150d8PWjDFlmR6hs5ZHMEQCIAWRs5y7b58Qrszlqsymb2ZnJtYlRvgohkbSQRWtl5WVAiAjvs/OJxJsb0afaBHQoY5POKlIs6TsaDU+6xZV1mZs6QEBBEdSIQKHfKAvFEBZvYLQDhs5muN094pSzvehyjfyjXiLNA0veSEDTIekSHL14fAG002IoAlZKCvUU150d8PWjDFlmR6hs5ZSrgEOINIiJi8mhym7fITFWBKaXWmGGFzvU17BScDfYN1KksIEAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABBCJRIBZV0TJCpxR530ke2cObPHWqWxzY0Ba/jLNUp013dB3eAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIawJHMEQCIHX/+DN7oavaEJzJjnIcVUgz9mY0VLyglR21zhcuA3LjAiAFXY5F4lr2Gu+QPcbwd9LpuW0Ut5Op7+w5K5bqn1Hf7gEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///wABAFMCAAAAAUDm+qYSaPF6EBAdYlU1gogq5IWL7hM2PbgP3ygfgl/8AAAAAAD/////AfBJAgAAAAAAF6kU9F+MyiaOwm5LvomRcPE4JQ189V6HAAAAAAEH2gBIMEUCIQCpJKPGxUyrQtmuxWtk3g6BNmfs6pBSLQFUsb1Jfh7P5gIgZ+3sydWMp5i87W7tPo/xrvwXfBdg60K6vq6i7aIIjc8BRzBEAiAFkbOcu2+fEK7M5arMpm9mZybWJUb4KIZG0kEVrZeVlQIgI77PzicSbG9Gn2gR0KGOTzipSLOk7Gg1PusWVdZmbOkBR1IhAod8oC8UQFm9gtAOGzma43T3ilLO96HKN/KNeIs0DS95IQNMh6RIcvXh8AbTTYigCVkoK9RTXnR3w9aMMWWZHqGzllKuAQ4g0iImLyaHKbt8hMVYEppdaYYYXO9TXsFJwN9g3UqSwgQBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgFlXRMkKnFHnfSR7Zw5s8dapbHNjQFr+Ms1SnTXd0Hd4BCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA" + }, + "supplementary": { + "hex": "70736274ff010204020000000104010201050101010601002207027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b2208027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068402430479d2da1310a024d2aab8e4c7b49d76cd51f45ee8127c159b0393a675b6f75c581ebe3d0817ddaf3bb598cfd7a022f1a87ed479664f6b947a47db5941cb201fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf473044022075fff8337ba1abda109cc98e721c554833f6663454bca0951db5ce172e0372e30220055d8e45e25af61aef903dc6f077d2e9b96d14b793a9efec392b96ea9f51dfee01220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff00010053020000000140e6faa61268f17a10101d62553582882ae4858bee13363db80fdf281f825ffc0000000000ffffffff01f04902000000000017a914f45f8cca268ec26e4bbe899170f138250d7cf55e8700000000220202877ca02f144059bd82d00e1b399ae374f78a52cef7a1ca37f28d788b340d2f79483045022100a924a3c6c54cab42d9aec56b64de0e813667ecea90522d0154b1bd497e1ecfe6022067edecc9d58ca798bced6eed3e8ff1aefc177c1760eb42babeaea2eda2088dcf012202034c87a44872f5e1f006d34d88a00959282bd4535e7477c3d68c3165991ea1b39647304402200591b39cbb6f9f10aecce5aacca66f666726d62546f8288646d24115ad979595022023becfce27126c6f469f6811d0a18e4f38a948b3a4ec68353eeb1655d6666ce901010447522102877ca02f144059bd82d00e1b399ae374f78a52cef7a1ca37f28d788b340d2f7921034c87a44872f5e1f006d34d88a00959282bd4535e7477c3d68c3165991ea1b39652ae010e20d222262f268729bb7c84c558129a5d6986185cef535ec149c0df60dd4a92c204010f0400000000011004feffffff00010308905f01000000000001042251201655d13242a71479df491ed9c39b3c75aa5b1cd8d016bf8cb354a74d77741dde010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "", + "public_key": "", + "prevout_txid": "04c2924add60dfc049c15e53ef5c1886695d9a1258c5847cbb2987262f2622d2", + "prevout_index": 0, + "amount": 150000, + "non_witness_utxo": "020000000140e6faa61268f17a10101d62553582882ae4858bee13363db80fdf281f825ffc0000000000ffffffff01f04902000000000017a914f45f8cca268ec26e4bbe899170f138250d7cf55e8700000000", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "2430479d2da1310a024d2aab8e4c7b49d76cd51f45ee8127c159b0393a675b6f75c581ebe3d0817ddaf3bb598cfd7a022f1a87ed479664f6b947a47db5941cb2" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51201655d13242a71479df491ed9c39b3c75aa5b1cd8d016bf8cb354a74d77741dde" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: two mixed input types - only eligible inputs contribute ECDH shares (NUMS internal key excluded)", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABASsQJwAAAAAAACJRICG+i0nY1uxr8GEwJe9oKFeYqXr2DtXaB7tet9ZpYewfAQ4gf5Bfm6DLtvgc10oey2Jgyq0+b4BBDkksi/VcCP3O/qIBDwQAAAAAARAE/v///0EU0yyikmsyLxRdds/IsGPuOPTphLUnXHBcd/Np6i3BmNfLAtYsiG2qoOgP46KHLogLMsc1KtA6pxDvSin9Ml3wPkEFOScrenQKes5AMDDn/ar06CwQzyxJYJtq1S4XnXP8cGrRiaIfQgBg15MfR5azciZnamg8g9yiiQ7BcMS84OFaASIVwFCSm3TBoElUt4tLYDXpel4HiloPKOyW1Ue/7prOgDrAIyDTLKKSazIvFF12z8iwY+449OmEtSdccFx382nqLcGY16zAARcgUJKbdMGgSVS3i0tgNel6XgeKWg8o7JbVR7/ums6AOsABGCDLAtYsiG2qoOgP46KHLogLMsc1KtA6pxDvSin9Ml3wPgABAR+ghgEAAAAAABYAFDch+nPCMFyy+I6EiS1r1rl3Jh5qIgICQ6DUDp3giCeUFhdSuuQrqQlSeEIJ8GNDDwryVjVKhbtHMEQCIEvgsV24URpQm0VnL8iNevy7bOFlEP7lL+UK0MIV+AO0AiANj93lbxA3Wm80S+AYlQrYIVTG31A3j6d9poXzrUU2jwEBAwQBAAAAIgYCQ6DUDp3giCeUFhdSuuQrqQlSeEIJ8GNDDwryVjVKhbsIAAAAgAEAAAABDiDnbAFxCDpMX7Sv4vbWHwCkcwG50B+NLkd4CrdULjd8CAEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAuV6etywGNj7MVToDBS5elCZS0I1aEHqn8ExcGFEAOY3Ih4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhA9/o4HeILO0WcbkJsYhPUF1MI8kgqROMyhCMmJNTa/Vcymb868WqzAsViY2OjfUSHB/fnoevqBke8zUhiA7srpgABAwgcJQAAAAAAAAEEIlEgLqIeHn2vtNQ7Mym1q9E4igU+7PPZwNHiakJEeFE284ABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABASsQJwAAAAAAACJRICG+i0nY1uxr8GEwJe9oKFeYqXr2DtXaB7tet9ZpYewfAQiIA0EFOScrenQKes5AMDDn/ar06CwQzyxJYJtq1S4XnXP8cGrRiaIfQgBg15MfR5azciZnamg8g9yiiQ7BcMS84OFaASIg0yyikmsyLxRdds/IsGPuOPTphLUnXHBcd/Np6i3BmNesIcBQkpt0waBJVLeLS2A16XpeB4paDyjsltVHv+6azoA6wAEOIH+QX5ugy7b4HNdKHstiYMqtPm+AQQ5JLIv1XAj9zv6iAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABQ3IfpzwjBcsviOhIkta9a5dyYeagEIawJHMEQCIEvgsV24URpQm0VnL8iNevy7bOFlEP7lL+UK0MIV+AO0AiANj93lbxA3Wm80S+AYlQrYIVTG31A3j6d9poXzrUU2jwEhAkOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7AQ4g52wBcQg6TF+0r+L21h8ApHMBudAfjS5HeAq3VC43fAgBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQLlenrcsBjY+zFU6AwUuXpQmUtCNWhB6p/BMXBhRADmNyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQPf6OB3iCztFnG5CbGIT1BdTCPJIKkTjMoQjJiTU2v1XMpm/OvFqswLFYmNjo31Ehwf356Hr6gZHvM1IYgO7K6YAAQMIHCUAAAAAAAABBCJRIC6iHh59r7TUOzMptavROIoFPuzz2cDR4mpCRHhRNvOAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001012b102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f010e207f905f9ba0cbb6f81cd74a1ecb6260caad3e6f80410e492c8bf55c08fdcefea2010f0400000000011004feffffff4114d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7cb02d62c886daaa0e80fe3a2872e880b32c7352ad03aa710ef4a29fd325df03e410539272b7a740a7ace403030e7fdaaf4e82c10cf2c49609b6ad52e179d73fc706ad189a21f420060d7931f4796b37226676a683c83dca2890ec170c4bce0e15a012215c050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac02320d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7acc001172050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac00001011fa0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a22020243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb47304402204be0b15db8511a509b45672fc88d7afcbb6ce16510fee52fe50ad0c215f803b402200d8fdde56f10375a6f344be018950ad82154c6df50378fa77da685f3ad45368f010103040100000022060243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb080000008001000000010e20e76c0171083a4c5fb4afe2f6d61f00a47301b9d01f8d2e47780ab7542e377c08010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682102e57a7adcb018d8fb3154e80c14b97a50994b42356841ea9fc13170614400e637221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840f7fa381de20b3b459c6e426c6213d4175308f2482a44e33284232624d4dafd573299bf3af16ab302c5626363a37d448707f7e7a1ebea0647bccd486203bb2ba6000103081c2500000000000001042251202ea21e1e7dafb4d43b3329b5abd1388a053eecf3d9c0d1e26a4244785136f380010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "9dab08c8eb0a4d9984ba709d580d009608f7b117dd4620eb4209c1d67a6c29d0", + "public_key": "02d32ca2926b322f145d76cfc8b063ee38f4e984b5275c705c77f369ea2dc198d7", + "prevout_txid": "a2fecefd085cf58b2c490e41806f3eadca6062cb1e4ad71cf8b6cba09b5f907f", + "prevout_index": 0, + "amount": 10000, + "non_witness_utxo": "020000000113f106b64b57b5b1376f9f6c47190f40cc06b3bedcb8aaba97850ab3d7f67d020000000000ffffffff01102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f00000000", + "witness_utxo": "102700000000000022512021be8b49d8d6ec6bf0613025ef68285798a97af60ed5da07bb5eb7d66961ec1f", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "087c372e54b70a78472e8d1fd0b90173a4001fd6f6e2afb45f4c3a0871016ce7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "a0860100000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "02e57a7adcb018d8fb3154e80c14b97a50994b42356841ea9fc13170614400e637", + "dleq_proof": "f7fa381de20b3b459c6e426c6213d4175308f2482a44e33284232624d4dafd573299bf3af16ab302c5626363a37d448707f7e7a1ebea0647bccd486203bb2ba6", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 9500, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51202ea21e1e7dafb4d43b3329b5abd1388a053eecf3d9c0d1e26a4244785136f380" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: three sp outputs (same scan key) - each output has distinct k value", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQQBBgEAAfsEAgAAAAABAR+AGgYAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCIH2bvrz6uqFt0Kqa+PjltDT3VIfbiiHm1QtEnjAT9WsrAiAlq8iYSKvhCgxaq6TPG5n553yKIkS2xy6zrFdRfncXuAEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiBw4GuGVZXEwnMdM/WmrSgPuHA1VGZimIDKXc2OkAfhmgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwighgEAAAAAAAEEIlEgpL1hojWVPFX7Ib8SF+ZZlw+BcVUweVNwtqhuui4/buABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkAAQMIoIYBAAAAAAABBCJRIEZ7FHQz3K03MqLFl4fZe6tlntq7U2+lo3EHQLVhS4t1AQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AAEDCKCGAQAAAAAAAQQiUSCkZ5TVNLTq9lSGWuFY2oR7xga4HYq3jhMySv5KWUnbhQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQABAwiQXwEAAAAAAAEEIlEgee9WiKP6f+/DkidFWx8cLwjHAIdCTWoA+EwxQhrKjaQA", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQQBBgEAAfsEAgAAAAABAR+AGgYAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhrAkcwRAIgfZu+vPq6oW3Qqpr4+OW0NPdUh9uKIebVC0SeMBP1aysCICWryJhIq+EKDFqrpM8bmfnnfIoiRLbHLrOsV1F+dxe4ASECyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8BDiBw4GuGVZXEwnMdM/WmrSgPuHA1VGZimIDKXc2OkAfhmgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwighgEAAAAAAAEEIlEgpL1hojWVPFX7Ib8SF+ZZlw+BcVUweVNwtqhuui4/buABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkAAQMIoIYBAAAAAAABBCJRIEZ7FHQz3K03MqLFl4fZe6tlntq7U2+lo3EHQLVhS4t1AQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AAEDCKCGAQAAAAAAAQQiUSCkZ5TVNLTq9lSGWuFY2oR7xga4HYq3jhMySv5KWUnbhQEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQABAwiQXwEAAAAAAAEEIlEgee9WiKP6f+/DkidFWx8cLwjHAIdCTWoA+EwxQhrKjaQA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501040106010001fb04020000000001011f801a0600000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402207d9bbebcfabaa16dd0aa9af8f8e5b434f75487db8a21e6d50b449e3013f56b2b022025abc89848abe10a0c5aaba4cf1b99f9e77c8a2244b6c72eb3ac57517e7717b80101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e2070e06b865595c4c2731d33f5a6ad280fb870355466629880ca5dcd8e9007e19a010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308a0860100000000000104225120a4bd61a235953c55fb21bf1217e659970f81715530795370b6a86eba2e3f6ee0010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900010308a0860100000000000104225120467b147433dcad3732a2c59787d97bab659edabb536fa5a3710740b5614b8b75010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900010308a0860100000000000104225120a46794d534b4eaf654865ae158da847bc606b81d8ab78e13324afe4a5949db85010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900010308905f010000000000010422512079ef5688a3fa7fefc39227455b1f1c2f08c70087424d6a00f84c31421aca8da400", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "9ae107908ecd5dca80986266543570b80f28ada6f5331d73c2c49555866be070", + "prevout_index": 0, + "amount": 400000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01801a0600000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "801a0600000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120a4bd61a235953c55fb21bf1217e659970f81715530795370b6a86eba2e3f6ee0" + }, + { + "output_index": 1, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120467b147433dcad3732a2c59787d97bab659edabb536fa5a3710740b5614b8b75" + }, + { + "output_index": 2, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120a46794d534b4eaf654865ae158da847bc606b81d8ab78e13324afe4a5949db85" + }, + { + "output_index": 3, + "amount": 90000, + "script": "512079ef5688a3fa7fefc39227455b1f1c2f08c70087424d6a00f84c31421aca8da4" + } + ], + "task": "finalize" + } + }, + { + "description": "can finalize: three sp outputs (same scan key) / two regular outputs - k values assigned independently of output index", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQYBBgEAAfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9HMEQCICcgzDtRc5g6XoCKbBZuU04tEOEjpGhrAqg+sdM9G3B6AiBdslMBO2N4nLRYrOIxjHkT9mvR6OIXHye1MrEw+uWDNQEBAwQBAAAAIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8IAAAAgAAAAAABDiDUQOda/N1TGlkeN6vSbkryvw9v8uGRgwI1Yej8VxOPSgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwighgEAAAAAAAEEIlEgcjuJtcY4edW50HowRRu91I43rAOOZvcm83ykCrJkq3IBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkAAQMIUMMAAAAAAAABBCJRIJxqPSOBjoIO0dDP3rljZXyOwyd7fZuGXHjXVX9d7daiAAEDCKCGAQAAAAAAAQQiUSCvFHbuA/XpiJDsVJYDYaxJHFbjCpPrKYD8MiuYN6dYugEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQABAwhQwwAAAAAAAAEEIlEgee9WiKP6f+/DkidFWx8cLwjHAIdCTWoA+EwxQhrKjaQAAQMIoIYBAAAAAAABBCJRIJ5nNdGxGWsLGu/g5NEOytKTdJZLn1mSBdF8qrYcp4VFAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AAEDCMgsAQAAAAAAAQQiUSBvxQb4BSqfWoqpuZDV6ZT0ld3tbUe6xEyqza3Y2Jkc0AA=", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQYBBgEAAfsEAgAAAAABAR8goQcAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhrAkcwRAIgJyDMO1FzmDpegIpsFm5TTi0Q4SOkaGsCqD6x0z0bcHoCIF2yUwE7Y3ictFis4jGMeRP2a9Ho4hcfJ7UysTD65YM1ASECyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8BDiDUQOda/N1TGlkeN6vSbkryvw9v8uGRgwI1Yej8VxOPSgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAihOzmFVF9yvW6JcUrrkJs+NUqEKpu4tWzQ7e0h34oZlZizEiikngvX6VzhBT98WyistUOmhwdgDjzomCLuMgIQABAwighgEAAAAAAAEEIlEgcjuJtcY4edW50HowRRu91I43rAOOZvcm83ykCrJkq3IBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkAAQMIUMMAAAAAAAABBCJRIJxqPSOBjoIO0dDP3rljZXyOwyd7fZuGXHjXVX9d7daiAAEDCKCGAQAAAAAAAQQiUSCvFHbuA/XpiJDsVJYDYaxJHFbjCpPrKYD8MiuYN6dYugEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQABAwhQwwAAAAAAAAEEIlEgee9WiKP6f+/DkidFWx8cLwjHAIdCTWoA+EwxQhrKjaQAAQMIoIYBAAAAAAABBCJRIJ5nNdGxGWsLGu/g5NEOytKTdJZLn1mSBdF8qrYcp4VFAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AAEDCMgsAQAAAAAAAQQiUSBvxQb4BSqfWoqpuZDV6ZT0ld3tbUe6xEyqza3Y2Jkc0AA=" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501060106010001fb04020000000001011f20a10700000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf47304402202720cc3b5173983a5e808a6c166e534e2d10e123a4686b02a83eb1d33d1b707a02205db253013b63789cb458ace2318c7913f66bd1e8e2171f27b532b130fae583350101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20d440e75afcdd531a591e37abd26e4af2bf0f6ff2e19183023561e8fc57138f4a010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee3202100010308a0860100000000000104225120723b89b5c63879d5b9d07a30451bbdd48e37ac038e66f726f37ca40ab264ab72010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce0390001030850c300000000000001042251209c6a3d23818e820ed1d0cfdeb963657c8ec3277b7d9b865c78d7557f5dedd6a200010308a0860100000000000104225120af1476ee03f5e98890ec54960361ac491c56e30a93eb2980fc322b9837a758ba010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce0390001030850c3000000000000010422512079ef5688a3fa7fefc39227455b1f1c2f08c70087424d6a00f84c31421aca8da400010308a08601000000000001042251209e6735d1b1196b0b1aefe0e4d10ecad29374964b9f599205d17caab61ca78545010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900010308c82c01000000000001042251206fc506f8052a9f5a8aa9b990d5e994f495dded6d47bac44caacdadd8d8991cd000", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "4a8f1357fce86135028391e1f26f0fbff24a6ed2ab371e591a53ddfc5ae740d4", + "prevout_index": 0, + "amount": 500000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff0120a10700000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "20a10700000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120723b89b5c63879d5b9d07a30451bbdd48e37ac038e66f726f37ca40ab264ab72" + }, + { + "output_index": 1, + "amount": 50000, + "script": "51209c6a3d23818e820ed1d0cfdeb963657c8ec3277b7d9b865c78d7557f5dedd6a2" + }, + { + "output_index": 2, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120af1476ee03f5e98890ec54960361ac491c56e30a93eb2980fc322b9837a758ba" + }, + { + "output_index": 3, + "amount": 50000, + "script": "512079ef5688a3fa7fefc39227455b1f1c2f08c70087424d6a00f84c31421aca8da4" + }, + { + "output_index": 4, + "amount": 100000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51209e6735d1b1196b0b1aefe0e4d10ecad29374964b9f599205d17caab61ca78545" + }, + { + "output_index": 5, + "amount": 77000, + "script": "51206fc506f8052a9f5a8aa9b990d5e994f495dded6d47bac44caacdadd8d8991cd0" + } + ], + "task": "finalize" + } + }, + { + "description": "in progress: two P2TR inputs, neither is signed", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAStADQMAAAAAACJRIOr+wb8f+Gc4KaZp0ODVHmm4+HjCR3lPlLOIEAxKsoGoAQMEAQAAAAEOII8FdrO+JFR/LnHnx5E/usrGtDeRW7vskxyrz2lTxHduAQ8EAAAAAAEQBP7///8BFyDIF7t1Ia/DXqlvO/snDm61Dd/6VWBie5Yf7ADymWUIvyIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQKTeleGEmR20MC8e8mIUIEPZ0rqwX2n+myKPS517xDUfiIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQLuFH43RADO9jLKEIl3bFF23tT1d58bq4VOAtAPzZGxoFAXmphUtj6HD5QQeouV+4GRyObGwMsqB/F0qs9lgFj4AAQErECcAAAAAAAAiUSByxJhK7EuuS9mftctjf98L3uLqGESO1I7dm3QHV5emHQEDBAEAAAABDiBK7+9qIrqY39KfGZyZ5uRg6lkyVeZUs7+YLAU/Zl6MNAEPBAAAAAABEAT+////ARcgQ6DUDp3giCeUFhdSuuQrqQlSeEIJ8GNDDwryVjVKhbsiHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCEDqyW+QCj++wxirIYxCPsMh/4IwcZ7wf2zwvtouIX3yhUiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaEDmalcdRGkQ4vvQ2EKCAsY6u1QmOGRDP70nIxFZc2vFlkZhZSkeUq+TMI9trZUVvluEWN/MmPHV/1+iGC5Lo3TnAAEDCLj5AgAAAAAAAQQiUSDt0WY14OrJfJ2zc3tD6kg1WVtBWfEASCMpWHOUAeiILwEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAStADQMAAAAAACJRIOr+wb8f+Gc4KaZp0ODVHmm4+HjCR3lPlLOIEAxKsoGoAQMEAQAAAAEOII8FdrO+JFR/LnHnx5E/usrGtDeRW7vskxyrz2lTxHduAQ8EAAAAAAEQBP7///8BE0H0bmbAbil+cc5EFPqPkPwQk9mSDUf4dxVqsFEFw84EyOObQdNQJibQGHfsRg0zU4EGw7AsBJbtGtmaKsE51XNoAQEXIMgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghApN6V4YSZHbQwLx7yYhQgQ9nSurBfaf6bIo9LnXvENR+Ih4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAu4UfjdEAM72MsoQiXdsUXbe1PV3nxurhU4C0A/NkbGgUBeamFS2PocPlBB6i5X7gZHI5sbAyyoH8XSqz2WAWPgABASsQJwAAAAAAACJRIHLEmErsS65L2Z+1y2N/3wve4uoYRI7Ujt2bdAdXl6YdAQMEAQAAAAEOIErv72oiupjf0p8ZnJnm5GDqWTJV5lSzv5gsBT9mXow0AQ8EAAAAAAEQBP7///8BE0EBEFz/OSaUDU1S949X1JV02VgDoq6nh+8L2ioapKWkXoboEVENOguuBRQ8Ud5Z1pUZmu/JO/JpJ970Af+bLuNgAQEXIEOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA6slvkAo/vsMYqyGMQj7DIf+CMHGe8H9s8L7aLiF98oVIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhA5mpXHURpEOL70NhCggLGOrtUJjhkQz+9JyMRWXNrxZZGYWUpHlKvkzCPba2VFb5bhFjfzJjx1f9fohguS6N05wABAwi4+QIAAAAAAAEEIlEg7dFmNeDqyXyds3N7Q+pINVlbQVnxAEgjKVhzlAHoiC8BCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001012b400d030000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a801030401000000010e208f0576b3be24547f2e71e7c7913fbacac6b437915bbbec931cabcf6953c4776e010f0400000000011004feffffff011720c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682102937a5786126476d0c0bc7bc98850810f674aeac17da7fa6c8a3d2e75ef10d47e221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840bb851f8dd10033bd8cb284225ddb145db7b53d5de7c6eae15380b403f3646c681405e6a6152d8fa1c3e5041ea2e57ee0647239b1b032ca81fc5d2ab3d960163e0001012b102700000000000022512072c4984aec4bae4bd99fb5cb637fdf0bdee2ea18448ed48edd9b74075797a61d01030401000000010e204aefef6a22ba98dfd29f199c99e6e460ea593255e654b3bf982c053f665e8c34010f0400000000011004feffffff01172043a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103ab25be4028fefb0c62ac863108fb0c87fe08c1c67bc1fdb3c2fb68b885f7ca15221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe06840e66a571d446910e2fbd0d8428202c63abb54263864433fbd27231159736bc596466165291e52af93308f6dad9515be5b8458dfcc98f1d5ff5fa2182e4ba374e700010308b8f90200000000000104225120edd16635e0eac97c9db3737b43ea4835595b4159f10048232958739401e8882f010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "2c0141a983cc711ec6a59cd7bccad7a159c43dab09d6e783e91facc865134da5", + "public_key": "02eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a8", + "prevout_txid": "6e77c45369cfab1c93ecbb5b9137b4c6caba3f91c7e7712e7f5424beb376058f", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "020000000113f106b64b57b5b1376f9f6c47190f40cc06b3bedcb8aaba97850ab3d7f67d020000000000ffffffff01400d030000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a800000000", + "witness_utxo": "400d030000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a8", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 1, + "private_key": "0f31b97d707a7f76eb099f41f372dbe12f2ef7a685ced8b6309eefc4e7b60afc", + "public_key": "0272c4984aec4bae4bd99fb5cb637fdf0bdee2ea18448ed48edd9b74075797a61d", + "prevout_txid": "348c5e663f052c98bfb354e6553259ea60e4e6999c199fd2df98ba226aefef4a", + "prevout_index": 0, + "amount": 10000, + "non_witness_utxo": "02000000012b9037ff41dd174e5522f0f4045c3f40436232af2600d4da5c9ea13cc3cab4b50000000000ffffffff01102700000000000022512072c4984aec4bae4bd99fb5cb637fdf0bdee2ea18448ed48edd9b74075797a61d00000000", + "witness_utxo": "102700000000000022512072c4984aec4bae4bd99fb5cb637fdf0bdee2ea18448ed48edd9b74075797a61d", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "02937a5786126476d0c0bc7bc98850810f674aeac17da7fa6c8a3d2e75ef10d47e", + "dleq_proof": "bb851f8dd10033bd8cb284225ddb145db7b53d5de7c6eae15380b403f3646c681405e6a6152d8fa1c3e5041ea2e57ee0647239b1b032ca81fc5d2ab3d960163e", + "input_index": 0 + }, + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03ab25be4028fefb0c62ac863108fb0c87fe08c1c67bc1fdb3c2fb68b885f7ca15", + "dleq_proof": "e66a571d446910e2fbd0d8428202c63abb54263864433fbd27231159736bc596466165291e52af93308f6dad9515be5b8458dfcc98f1d5ff5fa2182e4ba374e7", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 195000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120edd16635e0eac97c9db3737b43ea4835595b4159f10048232958739401e8882f" + } + ], + "task": "sign" + } + }, + { + "description": "in progress: one P2TR input / one sp output with no ECDH shares when PSBT_OUT_SCRIPT field is not set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABASughgEAAAAAACJRIOr+wb8f+Gc4KaZp0ODVHmm4+HjCR3lPlLOIEAxKsoGoAQ4gGO7ojX/Kt6ZwMBR271G7BhVP/avuATRXs3uzQbBSWwsBDwQAAAAAARAE/v///wEXIMgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AAEDCBhzAQAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAAfsEAgAAAAABASughgEAAAAAACJRIOr+wb8f+Gc4KaZp0ODVHmm4+HjCR3lPlLOIEAxKsoGoAQ4gGO7ojX/Kt6ZwMBR271G7BhVP/avuATRXs3uzQbBSWwsBDwQAAAAAARAE/v///wEXIMgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AAEDCBhzAQAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501010106010001fb04020000000001012ba086010000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a8010e2018eee88d7fcab7a670301476ef51bb06154ffdabee013457b37bb341b0525b0b010f0400000000011004feffffff011720c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf000103081873010000000000010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "2c0141a983cc711ec6a59cd7bccad7a159c43dab09d6e783e91facc865134da5", + "public_key": "02eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a8", + "prevout_txid": "0b5b52b041b37bb3573401eeabfd4f1506bb51ef76143070a6b7ca7f8de8ee18", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000113f106b64b57b5b1376f9f6c47190f40cc06b3bedcb8aaba97850ab3d7f67d020000000000ffffffff01a086010000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a800000000", + "witness_utxo": "a086010000000000225120eafec1bf1ff8673829a669d0e0d51e69b8f878c247794f94b388100c4ab281a8", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [], + "outputs": [ + { + "output_index": 0, + "amount": 95000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "sign" + } + }, + { + "description": "in progress: two inputs / one sp output, input 1 missing ECDH share when PSBT_OUT_SCRIPT field is not set", + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEf8EkCAAAAAAAWABQ3IfpzwjBcsviOhIkta9a5dyYeaiIGAkOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7CAAAAIABAAAAAQ4gSQv/chrf7ISJdgPfb7uyrbjEZTqaQrLW0VICyiQN4LEBDwQAAAAAARAE/v///wABAwhADQMAAAAAAAEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEf8EkCAAAAAAAWABQ3IfpzwjBcsviOhIkta9a5dyYeaiIGAkOg1A6d4IgnlBYXUrrkK6kJUnhCCfBjQw8K8lY1SoW7CAAAAIABAAAAAQ4gSQv/chrf7ISJdgPfb7uyrbjEZTqaQrLW0VICyiQN4LEBDwQAAAAAARAE/v///wABAwhADQMAAAAAAAEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040102010501010106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0682103eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b221e027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068408a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee320210001011ff0490200000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a22060243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb080000008001000000010e20490bff721adfec84897603df6fbbb2adb8c4653a9a42b2d6d15202ca240de0b1010f0400000000011004feffffff00010308400d030000000000010942027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce03900", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 1, + "private_key": "586b0810bbc3c7266971aeb7f8778b41707e092a1aeaf0d953b211f956e35541", + "public_key": "0243a0d40e9de0882794161752bae42ba90952784209f063430f0af256354a85bb", + "prevout_txid": "b1e00d24ca0252d1d6b2429a3a65c4b8adb2bb6fdf03768984ecdf1a72ff0b49", + "prevout_index": 0, + "amount": 150000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01f0490200000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a00000000", + "witness_utxo": "f0490200000000001600143721fa73c2305cb2f88e84892d6bd6b977261e6a", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 200000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "sign" + } + }, + { + "description": "in progress: one input / two sp outputs, input 0 missing ECDH share for output 0 when PSBT_OUT_SCRIPT field is not set", + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR9ADQMAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g/S309Ytav5uR/xoeQ+LjUj9QxqoZ1cIjYBQexIyagCEBDwQAAAAAARAE/v///yIdA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsIQMJH9SAORd/RNe3npYWiEnGLrP4eADEZ2fFCo84+Y79FSIeA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsQL4acjrvVeiYG5lZmpvBKzj4froBWMxwZokPImnK3kY7dzQal9KScZZNAcAkHMMi/VOQwpuZFg+CbzKTZYmMvwIAAQMIkF8BAAAAAAABCUIDZR0sBz/LAqTYLdpT8dUB13oDUGZnmFRkc7ISa2zRp94D8nDgpWMhg7arAQdOh35oANsA9cfF0vr7to+cKNSFRSQAAQMIkF8BAAAAAAABBCJRIGMlBrk4zY0hMZ/eTlk5KyP5juuXb0OS1jPxg+Iut/qxAQlCA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsAuDEwYe3IV+ZfISFp1tFkbbChHe5WhEjuZaSLTFUhgv4AA==", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQIBBgEAAfsEAgAAAAABAR9ADQMAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g/S309Ytav5uR/xoeQ+LjUj9QxqoZ1cIjYBQexIyagCEBDwQAAAAAARAE/v///yIdA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsIQMJH9SAORd/RNe3npYWiEnGLrP4eADEZ2fFCo84+Y79FSIeA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsQL4acjrvVeiYG5lZmpvBKzj4froBWMxwZokPImnK3kY7dzQal9KScZZNAcAkHMMi/VOQwpuZFg+CbzKTZYmMvwIAAQMIkF8BAAAAAAABCUIDZR0sBz/LAqTYLdpT8dUB13oDUGZnmFRkc7ISa2zRp94D8nDgpWMhg7arAQdOh35oANsA9cfF0vr7to+cKNSFRSQAAQMIkF8BAAAAAAABBCJRIGMlBrk4zY0hMZ/eTlk5KyP5juuXb0OS1jPxg+Iut/qxAQlCA1LXjEE5ADKtkYFqaX/HQNjrkJzwTXCIUmSwUfI4XiXsAuDEwYe3IV+ZfISFp1tFkbbChHe5WhEjuZaSLTFUhgv4AA==" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040101010501020106010001fb04020000000001011f400d0300000000001600141e2ad7872d329413a56df0968be338222783163b01030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20fd2df4f58b5abf9b91ff1a1e43e2e3523f50c6aa19d5c22360141ec48c9a8021010f0400000000011004feffffff221d0352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec2103091fd48039177f44d7b79e96168849c62eb3f87800c46767c50a8f38f98efd15221e0352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec40be1a723aef55e8981b99599a9bc12b38f87eba0158cc7066890f2269cade463b77341a97d29271964d01c0241cc322fd5390c29b99160f826f329365898cbf0200010308905f01000000000001094203651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de03f270e0a5632183b6ab01074e877e6800db00f5c7c5d2fafbb68f9c28d485452400010308905f0100000000000104225120632506b938cd8d21319fde4e59392b23f98eeb976f4392d633f183e22eb7fab10109420352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec02e0c4c187b7215f997c8485a75b4591b6c28477b95a1123b996922d3154860bf800", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "21809a8cc41e146023c2d519aac6503f52e3e2431e1aff919bbf5a8bf5f42dfd", + "prevout_index": 0, + "amount": 200000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01400d0300000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "400d0300000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "0352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec", + "ecdh_share": "03091fd48039177f44d7b79e96168849c62eb3f87800c46767c50a8f38f98efd15", + "dleq_proof": "be1a723aef55e8981b99599a9bc12b38f87eba0158cc7066890f2269cade463b77341a97d29271964d01c0241cc322fd5390c29b99160f826f329365898cbf02", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "03651d2c073fcb02a4d82dda53f1d501d77a0350666798546473b2126b6cd1a7de03f270e0a5632183b6ab01074e877e6800db00f5c7c5d2fafbb68f9c28d4854524" + }, + { + "output_index": 1, + "amount": 90000, + "sp_v0_info": "0352d78c41390032ad91816a697fc740d8eb909cf04d70885264b051f2385e25ec02e0c4c187b7215f997c8485a75b4591b6c28477b95a1123b996922d3154860bf8", + "script": "5120632506b938cd8d21319fde4e59392b23f98eeb976f4392d633f183e22eb7fab1" + } + ], + "task": "sign" + } + }, + { + "description": "in progress: large PSBT with nine mixed inputs / six outputs - some inputs signed", + "psbt": "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", + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBCQEFAQYBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCv5P5xeJJvJzjL4P4lgkWxL6PpXSHLT5RBhFoQysegEQIgTxC0f3slWNuXTK683/KVbOk8hyAZLZKir+WzNLjK69sBAQMEAQAAACIGAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/CAAAAIAAAAAAAQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQIQP70XPZxI1YxQIkJtBSeLyhe5qOIoJmaQGhsAueBLeZSSIdAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oIQMKGLm7QZm4kzDrF/juWseG4IU9zS88zfF0S5fOTt4FPiIdA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsIQNzctF59PYo2oLMvU5CF72wgJ8UF8mr6qNfqAXUitZVTCIeAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQQMBdpBBIfPrsN4/r5q9QBeOubIYjaBiw5VshQBfrUHPt70AXlXW13NqpBjSRrIuD/QYk1Bd6TS3UmUxGQNa4zN4iHgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKEAAE4PUZhvocl7ykEj0jJEfifXzQxfXwMCsxg72XxtSv/96ltgzm2Jd+Dq6tXqic+3NmjXHlNrLschhFxuyZwdfIh4DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGxApoctTrEZ/ir3CVP3UqIiNrVKO1f3DlEfEL2LQv9Wtaz2NlCTxIDqnxN3Z4SUW1kxisKSfZFariRM+2g/QYijpwABAR+ghgEAAAAAABYAFKaSURwHlXW/N1bavFatcdQoSmkOIgIC9bWfpeSSIh6/Vbp4rUQmBb6ulRZroeujJQ0Luqx+LtxIMEUCIQDW86lMNwk1Pl44m6LOVIhTgtjQk7SuDogcw67bVIQT5gIgYCeNhb9SMCp7OvVc3DvDb9hcT+L/G8pXhnqcD4F4I5EBAQMEAQAAACIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cCAAAAIABAAAAAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///yIdAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQIQOmqJsbmGqZVTPhe+1kUAtUG7DXOQce/irit++woMprzyIdAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oIQL2rnuKrJoPnJ8E6rSEBiFy3y442fL27DG0BLtaKGqr8CIdA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsIQKx0+0vpLwxagjrFIX6de191Uynqa4Y0MShfak/MMOF1SIeAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQQMNKailAu+mnNWwcxv/jWN1EQdtYiXy6mcIS63UoXn2h7KEceSyXo4BJM0WrIk3p2UwrNu6FJq4jUoFxoyMd5zMiHgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKEAzSs7YEG66pCh9rKVsyiZ5Xy0qc5eEz2tzTaM3B1f0meEgwOQL5AQ2zXTE7yaQVwb1L6f6bo52RR6Fg3gwUahDIh4DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGxA2EGjc60olrlyuM/qFjT/FKMPgNhM/W7xiJM5e480bIBRnJsWGnIkTQ6bZOVDbJjOndThegco/Jl7XHvPOc7LaAABAR+ghgEAAAAAABYAFNTckD9xFmAu41jsjt8yhOb/ApTjIgICZV712vBdKNHKc7qOIRMA2ytwQWc3GD4PqMNV7kwcusZHMEQCIFa6M2IBK4Lky66GLs4o83KwxU+Py57U4jt+4aJAxH3LAiAu7+Lw7ChjJdmPYrBo8OHbbyBrFE5zcAQHGFAikkIZlgEBAwQBAAAAIgYCZV712vBdKNHKc7qOIRMA2ytwQWc3GD4PqMNV7kwcusYIAAAAgAIAAAABDiCinXdnRAJ1ylMq9gkfClxWMpiVAg07C9iK/0O0EyAjnAEPBAAAAAABEAT+////Ih0CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRAhA99wb/JtZy/lDG9WosoecXTnUFXJILvTN+Gn1r8oJvbcIh0DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghA7+4YlO+uW9YuMRp5ELPz594pUE6lUI76OaGdk8vp70/Ih0DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwhA4YEqoz/MJ3d9JsfNm+JwmlhZYf8QdtghUD5QxU29mRvIh4CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRBA/S6MIrm2ctO7nibUttotw/ElRVqWn9jissG6eRB2rXGzjAH5IYw9Z3b9iV0vMGdISZbYXiaDkMK0M+bEshiR8SIeAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oQFLf+/AJXymx3iTJ1o1UnRxUvOaQBFT+N/0Q9ckD3+6F97rYpyrajlLNkJL1HZ6Qtafk82ygTfmOd/utE0cwW8ciHgOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobECT4eXUiIvBz+Au7Pqd6hROrYTyOhD8GjARA8HlY5NSe2NBfGxKWvRTWf+Lbhea9zl45NYuhi7t0qKG9SeOTLNAAAEBH6CGAQAAAAAAFgAU+20I37FPAB3JjPF8TXMisHvwdU8iAgMDoPRSjSZOjpUlZjS5RBTidI9ylicE/lfosKLMRNI4PUgwRQIhAPHJiHGnvcXpQWKgXdwlAwwjacuoChhT69OCAab/R2+bAiAwcmvl+cqFlnOAO2HBh/ue/BCqK5wRQJQK4Zh0SQCEwQEBAwQBAAAAIgYDA6D0Uo0mTo6VJWY0uUQU4nSPcpYnBP5X6LCizETSOD0IAAAAgAMAAAABDiAef87nvuWNqIGXxAlZpi4GA4Ca3jUTdJPfLPqPhVMEuwEPBAAAAAABEAT+////Ih0CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRAhA4ApmYxzwrE523VVfsMBHsZezSEkR5YwBlcYUqPpIonMIh0DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghApgLrHJk4Uv4IMxDW2mnjfcmwXfrAm8bgbUt6BEnL1jrIh0DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwhA6J9nx+lPkP3CDWmmQlUt4o190cGb3uCtKnqgui7XgamIh4CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRBAOBzjwayfx/alFTZFYlKYR2jo+9AUBwI59MsTsWeTx0zF7Wd8in6swXPpiNNTo/KJx+IUHbektBRcVJnsg382riIeAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oQDjgNGO2RQ29BRBlqBKm8mMQh/eVHkashOZtqBF1VxfAkxgOTUmCe4wJfKcJP+ktOT+VpdethJpBgC3E5FWKvekiHgOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobEBzKqCVep2yx1njmspdAWfvE9KjSkPIEunMnXEtRY97IoXadRHrFvYflgDSC+TpTf3SvDrjf9lD/DSUffw/3GeXAAEBH6CGAQAAAAAAFgAUCxhF9MgNq+LF3IpWf75BCnjkhsgiAgOokRvrWkj+EZywFQiM8MOhGM8CZ3JEiXLRtwx2SsWUEkgwRQIhAI6xqpQossxTVOjJ83WXR+mBcUUOwma2NYGtuLN5GZEtAiAcyk5nPjaUGgBKCzcPQaiPJ7ekQ4qeni8aJ+XSWucuoAEBAwQBAAAAIgYDqJEb61pI/hGcsBUIjPDDoRjPAmdyRIly0bcMdkrFlBIIAAAAgAQAAAABDiDTEVrd/vujHd9xq1Vn1DXMWPSAbUX6hlqLBw7J+HQZBwEPBAAAAAABEAT+////Ih0CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRAhAr70c4xvMn8XJLFAeYiVnN8r0ZIQiUv9BDU1thE4JwgYIh0DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bSghAn63wcSvzX5iq2rT0ronM6N0UiBkH5GQPr/nvMXb3GtdIh0DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGwhA8qIvNttH1KR6Qx109pgGovSmZHqu/f5Sy85SD44WMmhIh4CqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRBAClhJJxAoILe2yta8+wMaI6NzEq2H0j8ctag1m+LV/zm2oqL+N80NU+40fxPms1JXabLnifBpnLmFWI6sLa8Q3SIeAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oQHexVyM22b1OL3NBHrj2qWI1oTD0RMvrB6SJ9EeSHjdInXH9PbKKC7qjW4jDe3V57Nv2zhY4cA24HfyGv3nNG+ciHgOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobEBdDeiifw1SiALPM1Shr1B7zw/tQZ2mQcnAgHzXVOB6+HkLURxwXV+/YzBasir+BJf6zwcLWv6vzuOmkAVHdndWAAEBK6CGAQAAAAAAIlEgGjS87lYb/TgrBcYrc+fQV+BLJFCahT9ESfIsqm0OhG4BAwQBAAAAAQ4gsfKZWK5flwWjVkpKKhVMX8xeQKsZPQWZb+cyax1JLHUBDwQAAAAAARAE/v///wETQYv6bvGC8LNByfgK1XIywrL18N6Hm6PPOREKz6QvS/z7ZKU60Ia5MWjeoI02TZ8uEspzsqpe+pCE78ydUzjbpzkBARcg0VVxPFIM4tgnYWQhXWWatiPF9zBvhlLBdW4mgz6IbgEiHQKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVECEC0680fH8w0JlGhtoifdGCHq3igbpjG1g5SNV9zCGrz0EiHQMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKCEDgR44UaKsjRU+ahA6vo1MifnWK2JsNRk8QyOnRfuN1NgiHQOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobCEDC6hRWtuqjXUPQycx5JqRt1gVN5Yd3a7b3eMQzF1BacMiHgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEECRR+yzA77V8ZzUT2sv1cXAhNmHjBNYgTP+ITnk9LgaKn5oeXjvD1+6Hwi4DmiqY8CDaJXJn3R5XIMErq7e2qecIh4DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAsBpTeEaeGXpPGKcY5H5BFdFxncl9OlEE1P9/OCyUoefvkdSxgqyzVz+wI40E311npdnMPZCvcHIzy0A3L0AXfSIeA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsQMWxinlPXHCr6/lJRaRTLXWtT7nTmoUyhnzPe27NXRj336c7l9aPxygCDBfjRq7FhZZe42mNjfmyTUrLr3YSkr0AAQEroIYBAAAAAAAiUSB9MpjTAZ7Yi6uom4hSNzgr54j4jvBZX9Gw2LZ2FC+IsQEDBAEAAAABDiCBp/4cHISQptmqnniy22zkAiLZV1363Qtxiu3H/vKVeAEPBAAAAAABEAT+////ARNB4urcB+YqH5ofTpiVPlTxWKwnF+WJbvKha1Joww5wVOChubPTPmDCIySswy2qbD2ErgI6fNRbnzYeCzPkaG0rYgEBFyDQDhX7Ymp+/uhcW85nbWNrYEiRTpo0rOC0y8RLyUgHeiIdAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQIQKYXmmGYaXRuK1TJkuWT4LpPsiiuVp+6cAanQlq6tyeqCIdAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oIQIrw4MMwjWVxUSSwbf13VDJoCA60SH9vZjHuXRiJENfRiIdA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsIQMdRDjfhUtSoz+i4CSh3AmQJC5zNQkKcEyaHv6zxTP6oCIeAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQQJiuDFgrESAvuqXGi8tY7rAogbLXz7VHdnzK2QApSSRTvKrnY49zOtm/LW4USeZpCttd/ys2/vfIi0DK6OohPGIiHgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKEDvm0WnHnjpEHke2Rwl6s6KKhS5BxERwqhI7Ru3hWJWjdLsM5DvlmMKhsygj2z06xnoq0DtyeQcZauvVhB5Wf4vIh4DjtMiDnM0T5Hi0zOR4+FpHbOdrwbkI34ZftDQB78nKGxAVYkpCHHnF7zD/IYj0rkVzQU4vgWZRJalj7EmESMOiBbQKeTrT1/hq6mGZliZs8YtudxPs4Bv7dPWbmNCeiijQwABAFMCAAAAAf6hTz0WmysEANsUmWIhsxGCu56GyhaekbnHvZP5xz6IAAAAAAD/////AaCGAQAAAAAAF6kUDfEBNX9z5mWFAM9W86Ey17uK+92HAAAAAAEBIKCGAQAAAAAAF6kUDfEBNX9z5mWFAM9W86Ey17uK+92HIgICBQDxZ89mnn2sOeauzaHyjGa3jscJfu/vJdVPe+eF5/ZIMEUCIQCmTCZIZtcOdvOwv14luDghKePngGme1aUWZ8CmUvZXEAIgeLYxJQjXgu2O3YcKb7zisNhVi9Ea8A0M633VCVV8di4BAQMEAQAAAAEEFgAUxryBBexttgxNpTrDXNogQGnpDooiBgIFAPFnz2aefaw55q7NofKMZreOxwl+7+8l1U9754Xn9ggAAACABwAAAAEOILY2i7wzDN3+niVQ7bffwVrnTKybzH2Wf+gebyf4WXsdAQ8EAAAAAAEQBP7///8iHQKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVECEC/nhBzd+0b9ssqb3lbJVYwtGzYSFmVlkIAiTiQDFDhAgiHQMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKCECbwJ7I1p1k8qJQ8bXt+N9kuqzOWF/fww0QQbFjdDLxqoiHQOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobCECBhFFDGwZROzey3j2GBbHZ/ukNo8h9+mxaXecdvI89MwiHgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEECIByVRZiw+6+5UXxiLja/Ggpc6LyGOfKB/yOQv9XoRNGMESf1wMXfXoS0MnO0CSETcG54OytZ1h91cR5Qxs2oaIh4DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAFrWBSPe6/3g+QxDxhVA/6SQX26Q7lmyDohhDIssfIEJMudBArmoa6k50RL3HhiWKl1ZEzhoBlVZMK5/DxgaikiIeA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsQEqza91p6xzQ1LCurkA9zk21Ioxbo6KR3HJd4jOC0XNtJl17wz+DaQpcpWCXGfGegZUtTI1eKI/Qy4xkERBLgKMAAQBVAgAAAAEqNKwbDbd6gZjB4pACzEe7/NbtgwlgME0smjq1SEhrXQAAAAAA/////wGghgEAAAAAABl2qRRWm/MR5oo4N2e0P4MELfq+YAk+3oisAAAAACICAxmdLxVfMuuxZ66wzMpuWvtzQImN8bermTZQD21DkZAqSDBFAiEAsw3RMoUvT0Jm8aL3BaA9wJwe735Fn188ntpziIlkX2wCIHUFCsGTTSOAmeuNI02KUdHPLcJ/PBYId2sHNb426YKZAQEDBAEAAAAiBgMZnS8VXzLrsWeusMzKblr7c0CJjfG3q5k2UA9tQ5GQKggAAACACAAAAAEOIAO866U3nXPa6v5neXKwPc9+8wt/EOqoOtBLwL8A2LL3AQ8EAAAAAAEQBP7///8iHQKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVECEC88F1sIsgdjdhaqdOZ7qsGhgHyUvOcIAPdvWxe1LACC0iHQMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKCEC+hztkyWYon+ihBC5VepnR5taQDO2nyyZ5OJnZ7ugpVYiHQOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobCEDAOD9FxDcVq18FzqpFB1zFXcAm8Pf/LqFdqSOd6s02XAiHgKp8frCzEV2hPM96QBz/iDSLJR8khY7hisU0Kuh30cVEECZIlZY/t56jCQ36zghvcnTcAq8iW6Lbc74Tik0e3i8KwPm2jODbk9AdnOQw2ZEzgFrNrHVRpY1QPpR0LBAfbbXIh4DM2HT/3LzTmtOenvvluW4FR5mqXmtznU8OcWDy+V2bShAoJSMUX1wl2wOOcpnq/GechcEDb4XK7llNBM+b/o5QcFllBb1QGYrdWHvtwBktNcamxe2O8Vj9jDbRCLyc+DfEiIeA47TIg5zNE+R4tMzkePhaR2zna8G5CN+GX7Q0Ae/JyhsQO4KqmXKc8zFR7McK37SrjGk9Mza6nPyrdJGMNYI7emupdgIaIGG68pCuHfvqxPzXmDyENT2IGAvhQ/AcxwgHpEAAQMIMHUAAAAAAAABBCJRINA6VcvpbuoLg1XI/Jn3B807gK2xLydUq9rHGuqtqW+aAQlCAzNh0/9y805rTnp775bluBUeZql5rc51PDnFg8vldm0oAxJmWB4+hBy7lN5i6nNVg6IyxMiI+m7e8uwvhweJ/B3UAAEDCDB1AAAAAAAAAQQiUSDQv4Vfhajkbku8N6SDdwCu1yNrFvhZIiZ+P3fod89yEQEJQgMzYdP/cvNOa056e++W5bgVHmapea3OdTw5xYPL5XZtKAMSZlgePoQcu5TeYupzVYOiMsTIiPpu3vLsL4cHifwd1AABAwggTgAAAAAAAAEEIlEgDKU8okexUD4uZS/7pZa5MQfjl0xAeB6G37URMDw72XUBCUICqfH6wsxFdoTzPekAc/4g0iyUfJIWO4YrFNCrod9HFRACSkjXbiDUC89fLhpcP/6z3CqLO4jXmkhtVMnZ6qj6GI4AAQMIIE4AAAAAAAABBCJRIDBSfwGCsGbwBBPBaP5/7piBA3JBvBmKbqMCyZwFJGu8AQlCAqnx+sLMRXaE8z3pAHP+INIslHySFjuGKxTQq6HfRxUQAkpI124g1AvPXy4aXD/+s9wqizuI15pIbVTJ2eqo+hiOAAEDCBAnAAAAAAAAAQQiUSA2JSGCYG8o9ZWhqsZuGoHRnKWoy3VQRH3F6mvyOM/aRgEJQgOO0yIOczRPkeLTM5Hj4Wkds52vBuQjfhl+0NAHvycobAP4FHOETJ10ySH/F6WvQQtjNzSNevv/c4kbxcsMskywwAABAwhQwwAAAAAAAAEEIlEgb8UG+AUqn1qKqbmQ1emU9JXd7W1HusRMqs2t2NiZHNAA" + }, + "supplementary": { + "hex": "70736274ff0102040200000001040109010501060106010001fb04020000000001011fa0860100000000001600141e2ad7872d329413a56df0968be338222783163b220202c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf483045022100afe4fe7178926f2738cbe0fe258245b12fa3e95d21cb4f9441845a10cac7a01102204f10b47f7b2558db974caebcdff2956ce93c8720192d92a2afe5b334b8caebdb0101030401000000220602c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf080000008000000000010e20f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb71010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102103fbd173d9c48d58c5022426d05278bca17b9a8e2282666901a1b00b9e04b79949221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821030a18b9bb4199b89330eb17f8ee5ac786e0853dcd2f3ccdf1744b97ce4ede053e221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c21037372d179f4f628da82ccbd4e4217bdb0809f1417c9abeaa35fa805d48ad6554c221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df47151040c05da410487cfaec378febe6af5005e3ae6c86236818b0e55b214017eb5073edef40179575b5dcdaa9063491ac8b83fd0624d4177a4d2dd4994c4640d6b8ccde221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840001383d4661be8725ef29048f48c911f89f5f34317d7c0c0acc60ef65f1b52bfff7a96d8339b625df83abab57aa273edcd9a35c794dacbb1c861171bb267075f221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c40a6872d4eb119fe2af70953f752a22236b54a3b57f70e511f10bd8b42ff56b5acf6365093c480ea9f13776784945b59318ac2927d915aae244cfb683f4188a3a70001011fa086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e220202f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc483045022100d6f3a94c3709353e5e389ba2ce54885382d8d093b4ae0e881cc3aedb548413e6022060278d85bf52302a7b3af55cdc3bc36fd85c4fe2ff1bca57867a9c0f817823910101030401000000220602f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc080000008001000000010e20bcd485a709cb25d13463a1832db2194c6c9d9fe72b9699f4fe42c82bed93d326010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102103a6a89b1b986a995533e17bed64500b541bb0d739071efe2ae2b7efb0a0ca6bcf221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d282102f6ae7b8aac9a0f9c9f04eab484062172df2e38d9f2f6ec31b404bb5a286aabf0221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c2102b1d3ed2fa4bc316a08eb1485fa75ed7dd54ca7a9ae18d0c4a17da93f30c385d5221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df47151040c34a6a2940bbe9a7356c1cc6ffe358dd4441db58897cba99c212eb75285e7da1eca11c792c97a380493345ab224de9d94c2b36ee8526ae23528171a3231de733221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840334aced8106ebaa4287daca56cca26795f2d2a739784cf6b734da3370757f499e120c0e40be40436cd74c4ef26905706f52fa7fa6e8e76451e8583783051a843221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c40d841a373ad2896b972b8cfea1634ff14a30f80d84cfd6ef18893397b8f346c80519c9b161a72244d0e9b64e5436c98ce9dd4e17a0728fc997b5c7bcf39cecb680001011fa086010000000000160014d4dc903f7116602ee358ec8edf3284e6ff0294e3220202655ef5daf05d28d1ca73ba8e211300db2b70416737183e0fa8c355ee4c1cbac6473044022056ba3362012b82e4cbae862ece28f372b0c54f8fcb9ed4e23b7ee1a240c47dcb02202eefe2f0ec286325d98f62b068f0e1db6f206b144e73700407185022924219960101030401000000220602655ef5daf05d28d1ca73ba8e211300db2b70416737183e0fa8c355ee4c1cbac6080000008002000000010e20a29d7767440275ca532af6091f0a5c56329895020d3b0bd88aff43b41320239c010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102103df706ff26d672fe50c6f56a2ca1e7174e75055c920bbd337e1a7d6bf2826f6dc221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d282103bfb86253beb96f58b8c469e442cfcf9f78a5413a95423be8e686764f2fa7bd3f221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c21038604aa8cff309dddf49b1f366f89c269616587fc41db608540f9431536f6646f221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df47151040fd2e8c22b9b672d3bb9e26d4b6da2dc3f125455a969fd8e2b2c1ba791076ad71b38c01f9218c3d6776fd895d2f3067484996d85e268390c2b433e6c4b21891f1221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d284052dffbf0095f29b1de24c9d68d549d1c54bce6900454fe37fd10f5c903dfee85f7bad8a72ada8e52cd9092f51d9e90b5a7e4f36ca04df98e77fbad1347305bc7221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c4093e1e5d4888bc1cfe02eecfa9dea144ead84f23a10fc1a301103c1e56393527b63417c6c4a5af45359ff8b6e179af73978e4d62e862eedd2a286f5278e4cb3400001011fa086010000000000160014fb6d08dfb14f001dc98cf17c4d7322b07bf0754f22020303a0f4528d264e8e95256634b94414e2748f72962704fe57e8b0a2cc44d2383d483045022100f1c98871a7bdc5e94162a05ddc25030c2369cba80a1853ebd38201a6ff476f9b022030726be5f9ca859673803b61c187fb9efc10aa2b9c1140940ae19874490084c1010103040100000022060303a0f4528d264e8e95256634b94414e2748f72962704fe57e8b0a2cc44d2383d080000008003000000010e201e7fcee7bee58da88197c40959a62e0603809ade35137493df2cfa8f855304bb010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df47151021038029998c73c2b139db75557ec3011ec65ecd212447963006571852a3e92289cc221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d282102980bac7264e14bf820cc435b69a78df726c177eb026f1b81b52de811272f58eb221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c2103a27d9f1fa53e43f70835a6990954b78a35f747066f7b82b4a9ea82e8bb5e06a6221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df47151040381ce3c1ac9fc7f6a51536456252984768e8fbd014070239f4cb13b16793c74cc5ed677c8a7eacc173e988d353a3f289c7e2141db7a4b4145c5499ec837f36ae221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d284038e03463b6450dbd051065a812a6f2631087f7951e46ac84e66da811755717c093180e4d49827b8c097ca7093fe92d393f95a5d7ad849a41802dc4e4558abde9221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c40732aa0957a9db2c759e39aca5d0167ef13d2a34a43c812e9cc9d712d458f7b2285da7511eb16f61f9600d20be4e94dfdd2bc3ae37fd943fc34947dfc3fdc67970001011fa0860100000000001600140b1845f4c80dabe2c5dc8a567fbe410a78e486c8220203a8911beb5a48fe119cb015088cf0c3a118cf026772448972d1b70c764ac594124830450221008eb1aa9428b2cc5354e8c9f3759747e98171450ec266b63581adb8b37919912d02201cca4e673e36941a004a0b370f41a88f27b7a4438a9e9e2f1a27e5d25ae72ea00101030401000000220603a8911beb5a48fe119cb015088cf0c3a118cf026772448972d1b70c764ac59412080000008004000000010e20d3115addfefba31ddf71ab5567d435cc58f4806d45fa865a8b070ec9f8741907010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102102bef4738c6f327f1724b1407988959cdf2bd19210894bfd043535b61138270818221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821027eb7c1c4afcd7e62ab6ad3d2ba2733a3745220641f91903ebfe7bcc5dbdc6b5d221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c2103ca88bcdb6d1f5291e90c75d3da601a8bd29991eabbf7f94b2f39483e3858c9a1221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510400a584927102820b7b6cad6bcfb031a23a37312ad87d23f1cb5a8359be2d5ff39b6a2a2fe37cd0d53ee347f13e6b3525769b2e789f0699cb985588eac2daf10dd221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d284077b1572336d9bd4e2f73411eb8f6a96235a130f444cbeb07a489f447921e37489d71fd3db28a0bbaa35b88c37b7579ecdbf6ce1638700db81dfc86bf79cd1be7221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c405d0de8a27f0d528802cf3354a1af507bcf0fed419da641c9c0807cd754e07af8790b511c705d5fbf63305ab22afe0497facf070b5afeafcee3a69005477677560001012ba0860100000000002251201a34bcee561bfd382b05c62b73e7d057e04b24509a853f4449f22caa6d0e846e01030401000000010e20b1f29958ae5f9705a3564a4a2a154c5fcc5e40ab193d05996fe7326b1d492c75010f0400000000011004feffffff011720d155713c520ce2d8276164215d659ab623c5f7306f8652c1756e26833e886e01221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102102d3af347c7f30d0994686da227dd1821eade281ba631b583948d57dcc21abcf41221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d282103811e3851a2ac8d153e6a103abe8d4c89f9d62b626c35193c4323a745fb8dd4d8221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c21030ba8515adbaa8d750f432731e49a91b7581537961dddaedbdde310cc5d4169c3221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510409147ecb303bed5f19cd44f6b2fd5c5c084d9878c13588133fe2139e4f4b81a2a7e687978ef0f5fba1f08b80e68aa63c0836895c99f74795c8304aeaededaa79c221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840b01a5378469e197a4f18a718e47e4115d1719dc97d3a5104d4ff7f382c94a1e7ef91d4b182acb3573fb0238d04df5d67a5d9cc3d90af707233cb40372f40177d221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c40c5b18a794f5c70abebf94945a4532d75ad4fb9d39a8532867ccf7b6ecd5d18f7dfa73b97d68fc728020c17e346aec585965ee3698d8df9b24d4acbaf761292bd0001012ba0860100000000002251207d3298d3019ed88baba89b885237382be788f88ef0595fd1b0d8b676142f88b101030401000000010e2081a7fe1c1c8490a6d9aa9e78b2db6ce40222d9575dfadd0b718aedc7fef29578010f0400000000011004feffffff011720d00e15fb626a7efee85c5bce676d636b6048914e9a34ace0b4cbc44bc948077a221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102102985e698661a5d1b8ad53264b964f82e93ec8a2b95a7ee9c01a9d096aeadc9ea8221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821022bc3830cc23595c54492c1b7f5dd50c9a0203ad121fdbd98c7b9746224435f46221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c21031d4438df854b52a33fa2e024a1dc0990242e7335090a704c9a1efeb3c533faa0221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715104098ae0c582b11202fbaa5c68bcb58eeb02881b2d7cfb547767ccad90029492453bcaae7638f733ad9bf2d6e1449e6690adb5dff2b36fef7c88b40cae8ea213c62221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840ef9b45a71e78e910791ed91c25eace8a2a14b9071111c2a848ed1bb78562568dd2ec3390ef96630a86cca08f6cf4eb19e8ab40edc9e41c65abaf56107959fe2f221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c405589290871e717bcc3fc8623d2b915cd0538be05994496a58fb12611230e8816d029e4eb4f5fe1aba986665899b3c62db9dc4fb3806fedd3d66e63427a28a343000100530200000001fea14f3d169b2b0400db14996221b31182bb9e86ca169e91b9c7bd93f9c73e880000000000ffffffff01a08601000000000017a9140df101357f73e6658500cf56f3a132d7bb8afbdd8700000000010120a08601000000000017a9140df101357f73e6658500cf56f3a132d7bb8afbdd872202020500f167cf669e7dac39e6aecda1f28c66b78ec7097eefef25d54f7be785e7f6483045022100a64c264866d70e76f3b0bf5e25b8382129e3e780699ed5a51667c0a652f65710022078b6312508d782ed8edd870a6fbce2b0d8558bd11af00d0ceb7dd509557c762e01010304010000000104160014c6bc8105ec6db60c4da53ac35cda204069e90e8a2206020500f167cf669e7dac39e6aecda1f28c66b78ec7097eefef25d54f7be785e7f6080000008007000000010e20b6368bbc330cddfe9e2550edb7dfc15ae74cac9bcc7d967fe81e6f27f8597b1d010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102102fe7841cddfb46fdb2ca9bde56c9558c2d1b36121665659080224e24031438408221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2821026f027b235a7593ca8943c6d7b7e37d92eab339617f7f0c344106c58dd0cbc6aa221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c21020611450c6c1944ecdecb78f61816c767fba4368f21f7e9b169779c76f23cf4cc221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715104088072551662c3eebee545f188b8dafc682973a2f218e7ca07fc8e42ff57a1134630449fd703177d7a12d0c9ced024844dc1b9e0ecad67587dd5c479431b36a1a221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d284016b58148f7baff783e4310f185503fe92417dba43b966c83a2184322cb1f20424cb9d040ae6a1aea4e7444bdc786258a975644ce1a0195564c2b9fc3c606a292221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c404ab36bdd69eb1cd0d4b0aeae403dce4db5228c5ba3a291dc725de23382d1736d265d7bc33f83690a5ca5609719f19e81952d4c8d5e288fd0cb8c6411104b80a30001005502000000012a34ac1b0db77a8198c1e29002cc47bbfcd6ed830960304d2c9a3ab548486b5d0000000000ffffffff01a0860100000000001976a914569bf311e68a383767b43f83042dfabe60093ede88ac00000000220203199d2f155f32ebb167aeb0ccca6e5afb7340898df1b7ab9936500f6d4391902a483045022100b30dd132852f4f4266f1a2f705a03dc09c1eef7e459f5f3c9eda738889645f6c022075050ac1934d238099eb8d234d8a51d1cf2dc27f3c1608776b0735be36e982990101030401000000220603199d2f155f32ebb167aeb0ccca6e5afb7340898df1b7ab9936500f6d4391902a080000008008000000010e2003bceba5379d73daeafe677972b03dcf7ef30b7f10eaa83ad04bc0bf00d8b2f7010f0400000000011004feffffff221d02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715102102f3c175b08b207637616aa74e67baac1a1807c94bce70800f76f5b17b52c0082d221d033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d282102fa1ced932598a27fa28410b955ea67479b5a4033b69f2c99e4e26767bba0a556221d038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c210300e0fd1710dc56ad7c173aa9141d731577009bc3dffcba8576a48e77ab34d970221e02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df4715104099225658fede7a8c2437eb3821bdc9d3700abc896e8b6dcef84e29347b78bc2b03e6da33836e4f40767390c36644ce016b36b1d546963540fa51d0b0407db6d7221e033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d2840a0948c517d70976c0e39ca67abf19e7217040dbe172bb96534133e6ffa3941c1659416f540662b7561efb70064b4d71a9b17b63bc563f630db4422f273e0df12221e038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c40ee0aaa65ca73ccc547b31c2b7ed2ae31a4f4ccdaea73f2add24630d608ede9aea5d808688186ebca42b877efab13f35e60f210d4f620602f850fc0731c201e910001030830750000000000000104225120d03a55cbe96eea0b8355c8fc99f707cd3b80adb12f2754abdac71aeaada96f9a010942033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd40001030830750000000000000104225120d0bf855f85a8e46e4bbc37a4837700aed7236b16f85922267e3f77e877cf7211010942033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd400010308204e00000000000001042251200ca53ca247b1503e2e652ffba596b93107e3974c40781e86dfb511303c3bd97501094202a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e00010308204e000000000000010422512030527f0182b066f00413c168fe7fee9881037241bc198a6ea302c99c05246bbc01094202a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e000103081027000000000000010422512036252182606f28f595a1aac66e1a81d19ca5a8cb7550447dc5ea6bf238cfda46010942038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c03f81473844c9d74c921ff17a5af410b6337348d7afbff73891bc5cb0cb24cb0c00001030850c300000000000001042251206fc506f8052a9f5a8aa9b990d5e994f495dded6d47bac44caacdadd8d8991cd000", + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 1, + "private_key": "295c2eedddd8331d20b5d4cf9e69bb523ed85cb0bf35ab12e04fea66fe6d4a4a", + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "prevout_txid": "26d393ed2bc842fef499962be79f9d6c4c19b22d83a16334d125cb09a785d4bc", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e00000000", + "witness_utxo": "a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 2, + "private_key": "e6db4a04e2fc29745ea1a9dcf1fed7449c8228ffe0503d8171e64126d5399800", + "public_key": "02655ef5daf05d28d1ca73ba8e211300db2b70416737183e0fa8c355ee4c1cbac6", + "prevout_txid": "9c232013b443ff8ad80b3b0d02959832565c0a1f09f62a53ca75024467779da2", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001d041c742ca364472d1a18c7a8eae07e6e904a9ea1b85f198525fb83ef276e3430000000000ffffffff01a086010000000000160014d4dc903f7116602ee358ec8edf3284e6ff0294e300000000", + "witness_utxo": "a086010000000000160014d4dc903f7116602ee358ec8edf3284e6ff0294e3", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 3, + "private_key": "f5208ed67b0019ba4e306aff029d247931e0dfacd1fe6e69091bc6bc70a42619", + "public_key": "0303a0f4528d264e8e95256634b94414e2748f72962704fe57e8b0a2cc44d2383d", + "prevout_txid": "bb0453858ffa2cdf93741335de9a8003062ea65909c49781a88de5bee7ce7f1e", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "020000000152262cd5d402bf32616d07fc03286a8f7fe78af7ac411dfff41655ddc1011e6f0000000000ffffffff01a086010000000000160014fb6d08dfb14f001dc98cf17c4d7322b07bf0754f00000000", + "witness_utxo": "a086010000000000160014fb6d08dfb14f001dc98cf17c4d7322b07bf0754f", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 4, + "private_key": "0c19c34dc1005feb5ca60104d20472f7f2f97bd4d521264618196bf71155b20a", + "public_key": "03a8911beb5a48fe119cb015088cf0c3a118cf026772448972d1b70c764ac59412", + "prevout_txid": "071974f8c90e078b5a86fa456d80f458cc35d46755ab71df1da3fbfedd5a11d3", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001e298eaf24fe1ca68b41e4b6b83cc3d91ced99c6e78d5b992cfb15771b54570640000000000ffffffff01a0860100000000001600140b1845f4c80dabe2c5dc8a567fbe410a78e486c800000000", + "witness_utxo": "a0860100000000001600140b1845f4c80dabe2c5dc8a567fbe410a78e486c8", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 5, + "private_key": "2b8676a5f410a07ce7f4e9899f14a2e3d5528dadf05a164ea566fc192299d01a", + "public_key": "021a34bcee561bfd382b05c62b73e7d057e04b24509a853f4449f22caa6d0e846e", + "prevout_txid": "752c491d6b32e76f99053d19ab405ecc5f4c152a4a4a56a305975fae5899f2b1", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "02000000011730833ecb5be01362d7149522604484216e1c7b18cf313d1cf1543ef85df3b60000000000ffffffff01a0860100000000002251201a34bcee561bfd382b05c62b73e7d057e04b24509a853f4449f22caa6d0e846e00000000", + "witness_utxo": "a0860100000000002251201a34bcee561bfd382b05c62b73e7d057e04b24509a853f4449f22caa6d0e846e", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 6, + "private_key": "de6b1726d3f5997e5db395ead26fba223c64f20be9ccde470bb7530a9d301445", + "public_key": "027d3298d3019ed88baba89b885237382be788f88ef0595fd1b0d8b676142f88b1", + "prevout_txid": "7895f2fec7ed8a710bddfa5d57d92202e46cdbb2789eaad9a690841c1cfea781", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001e93532e0eda39c4d39da2d3f91d14529bc435fc2efb9196e25fbaac4b4e89b810000000000ffffffff01a0860100000000002251207d3298d3019ed88baba89b885237382be788f88ef0595fd1b0d8b676142f88b100000000", + "witness_utxo": "a0860100000000002251207d3298d3019ed88baba89b885237382be788f88ef0595fd1b0d8b676142f88b1", + "sequence": 4294967294, + "signed": false + }, + { + "input_index": 7, + "private_key": "d8bc8d0e1233a97133f3573d6dceb6736e8b6d2e4839925145022ea3efdad8f8", + "public_key": "020500f167cf669e7dac39e6aecda1f28c66b78ec7097eefef25d54f7be785e7f6", + "prevout_txid": "1d7b59f8276f1ee87f967dcc9bac4ce75ac1dfb7ed50259efedd0c33bc8b36b6", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "0200000001fea14f3d169b2b0400db14996221b31182bb9e86ca169e91b9c7bd93f9c73e880000000000ffffffff01a08601000000000017a9140df101357f73e6658500cf56f3a132d7bb8afbdd8700000000", + "witness_utxo": "a08601000000000017a9140df101357f73e6658500cf56f3a132d7bb8afbdd87", + "sequence": 4294967294, + "signed": true + }, + { + "input_index": 8, + "private_key": "81e30f5b5d049bdf5c5bea9c3329bf57cc8b473240182a9f2a6eee07435bd54a", + "public_key": "03199d2f155f32ebb167aeb0ccca6e5afb7340898df1b7ab9936500f6d4391902a", + "prevout_txid": "f7b2d800bfc04bd03aa8ea107f0bf37ecf3db0727967feeada739d37a5ebbc03", + "prevout_index": 0, + "amount": 100000, + "non_witness_utxo": "02000000012a34ac1b0db77a8198c1e29002cc47bbfcd6ed830960304d2c9a3ab548486b5d0000000000ffffffff01a0860100000000001976a914569bf311e68a383767b43f83042dfabe60093ede88ac00000000", + "sequence": 4294967294, + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "030a18b9bb4199b89330eb17f8ee5ac786e0853dcd2f3ccdf1744b97ce4ede053e", + "dleq_proof": "001383d4661be8725ef29048f48c911f89f5f34317d7c0c0acc60ef65f1b52bfff7a96d8339b625df83abab57aa273edcd9a35c794dacbb1c861171bb267075f", + "input_index": 0 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "03fbd173d9c48d58c5022426d05278bca17b9a8e2282666901a1b00b9e04b79949", + "dleq_proof": "c05da410487cfaec378febe6af5005e3ae6c86236818b0e55b214017eb5073edef40179575b5dcdaa9063491ac8b83fd0624d4177a4d2dd4994c4640d6b8ccde", + "input_index": 0 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "037372d179f4f628da82ccbd4e4217bdb0809f1417c9abeaa35fa805d48ad6554c", + "dleq_proof": "a6872d4eb119fe2af70953f752a22236b54a3b57f70e511f10bd8b42ff56b5acf6365093c480ea9f13776784945b59318ac2927d915aae244cfb683f4188a3a7", + "input_index": 0 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "02f6ae7b8aac9a0f9c9f04eab484062172df2e38d9f2f6ec31b404bb5a286aabf0", + "dleq_proof": "334aced8106ebaa4287daca56cca26795f2d2a739784cf6b734da3370757f499e120c0e40be40436cd74c4ef26905706f52fa7fa6e8e76451e8583783051a843", + "input_index": 1 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "03a6a89b1b986a995533e17bed64500b541bb0d739071efe2ae2b7efb0a0ca6bcf", + "dleq_proof": "c34a6a2940bbe9a7356c1cc6ffe358dd4441db58897cba99c212eb75285e7da1eca11c792c97a380493345ab224de9d94c2b36ee8526ae23528171a3231de733", + "input_index": 1 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "02b1d3ed2fa4bc316a08eb1485fa75ed7dd54ca7a9ae18d0c4a17da93f30c385d5", + "dleq_proof": "d841a373ad2896b972b8cfea1634ff14a30f80d84cfd6ef18893397b8f346c80519c9b161a72244d0e9b64e5436c98ce9dd4e17a0728fc997b5c7bcf39cecb68", + "input_index": 1 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "03bfb86253beb96f58b8c469e442cfcf9f78a5413a95423be8e686764f2fa7bd3f", + "dleq_proof": "52dffbf0095f29b1de24c9d68d549d1c54bce6900454fe37fd10f5c903dfee85f7bad8a72ada8e52cd9092f51d9e90b5a7e4f36ca04df98e77fbad1347305bc7", + "input_index": 2 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "03df706ff26d672fe50c6f56a2ca1e7174e75055c920bbd337e1a7d6bf2826f6dc", + "dleq_proof": "fd2e8c22b9b672d3bb9e26d4b6da2dc3f125455a969fd8e2b2c1ba791076ad71b38c01f9218c3d6776fd895d2f3067484996d85e268390c2b433e6c4b21891f1", + "input_index": 2 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "038604aa8cff309dddf49b1f366f89c269616587fc41db608540f9431536f6646f", + "dleq_proof": "93e1e5d4888bc1cfe02eecfa9dea144ead84f23a10fc1a301103c1e56393527b63417c6c4a5af45359ff8b6e179af73978e4d62e862eedd2a286f5278e4cb340", + "input_index": 2 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "02980bac7264e14bf820cc435b69a78df726c177eb026f1b81b52de811272f58eb", + "dleq_proof": "38e03463b6450dbd051065a812a6f2631087f7951e46ac84e66da811755717c093180e4d49827b8c097ca7093fe92d393f95a5d7ad849a41802dc4e4558abde9", + "input_index": 3 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "038029998c73c2b139db75557ec3011ec65ecd212447963006571852a3e92289cc", + "dleq_proof": "381ce3c1ac9fc7f6a51536456252984768e8fbd014070239f4cb13b16793c74cc5ed677c8a7eacc173e988d353a3f289c7e2141db7a4b4145c5499ec837f36ae", + "input_index": 3 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "03a27d9f1fa53e43f70835a6990954b78a35f747066f7b82b4a9ea82e8bb5e06a6", + "dleq_proof": "732aa0957a9db2c759e39aca5d0167ef13d2a34a43c812e9cc9d712d458f7b2285da7511eb16f61f9600d20be4e94dfdd2bc3ae37fd943fc34947dfc3fdc6797", + "input_index": 3 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "027eb7c1c4afcd7e62ab6ad3d2ba2733a3745220641f91903ebfe7bcc5dbdc6b5d", + "dleq_proof": "77b1572336d9bd4e2f73411eb8f6a96235a130f444cbeb07a489f447921e37489d71fd3db28a0bbaa35b88c37b7579ecdbf6ce1638700db81dfc86bf79cd1be7", + "input_index": 4 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02bef4738c6f327f1724b1407988959cdf2bd19210894bfd043535b61138270818", + "dleq_proof": "0a584927102820b7b6cad6bcfb031a23a37312ad87d23f1cb5a8359be2d5ff39b6a2a2fe37cd0d53ee347f13e6b3525769b2e789f0699cb985588eac2daf10dd", + "input_index": 4 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "03ca88bcdb6d1f5291e90c75d3da601a8bd29991eabbf7f94b2f39483e3858c9a1", + "dleq_proof": "5d0de8a27f0d528802cf3354a1af507bcf0fed419da641c9c0807cd754e07af8790b511c705d5fbf63305ab22afe0497facf070b5afeafcee3a6900547767756", + "input_index": 4 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "03811e3851a2ac8d153e6a103abe8d4c89f9d62b626c35193c4323a745fb8dd4d8", + "dleq_proof": "b01a5378469e197a4f18a718e47e4115d1719dc97d3a5104d4ff7f382c94a1e7ef91d4b182acb3573fb0238d04df5d67a5d9cc3d90af707233cb40372f40177d", + "input_index": 5 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02d3af347c7f30d0994686da227dd1821eade281ba631b583948d57dcc21abcf41", + "dleq_proof": "9147ecb303bed5f19cd44f6b2fd5c5c084d9878c13588133fe2139e4f4b81a2a7e687978ef0f5fba1f08b80e68aa63c0836895c99f74795c8304aeaededaa79c", + "input_index": 5 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "030ba8515adbaa8d750f432731e49a91b7581537961dddaedbdde310cc5d4169c3", + "dleq_proof": "c5b18a794f5c70abebf94945a4532d75ad4fb9d39a8532867ccf7b6ecd5d18f7dfa73b97d68fc728020c17e346aec585965ee3698d8df9b24d4acbaf761292bd", + "input_index": 5 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "022bc3830cc23595c54492c1b7f5dd50c9a0203ad121fdbd98c7b9746224435f46", + "dleq_proof": "ef9b45a71e78e910791ed91c25eace8a2a14b9071111c2a848ed1bb78562568dd2ec3390ef96630a86cca08f6cf4eb19e8ab40edc9e41c65abaf56107959fe2f", + "input_index": 6 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02985e698661a5d1b8ad53264b964f82e93ec8a2b95a7ee9c01a9d096aeadc9ea8", + "dleq_proof": "98ae0c582b11202fbaa5c68bcb58eeb02881b2d7cfb547767ccad90029492453bcaae7638f733ad9bf2d6e1449e6690adb5dff2b36fef7c88b40cae8ea213c62", + "input_index": 6 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "031d4438df854b52a33fa2e024a1dc0990242e7335090a704c9a1efeb3c533faa0", + "dleq_proof": "5589290871e717bcc3fc8623d2b915cd0538be05994496a58fb12611230e8816d029e4eb4f5fe1aba986665899b3c62db9dc4fb3806fedd3d66e63427a28a343", + "input_index": 6 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "026f027b235a7593ca8943c6d7b7e37d92eab339617f7f0c344106c58dd0cbc6aa", + "dleq_proof": "16b58148f7baff783e4310f185503fe92417dba43b966c83a2184322cb1f20424cb9d040ae6a1aea4e7444bdc786258a975644ce1a0195564c2b9fc3c606a292", + "input_index": 7 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02fe7841cddfb46fdb2ca9bde56c9558c2d1b36121665659080224e24031438408", + "dleq_proof": "88072551662c3eebee545f188b8dafc682973a2f218e7ca07fc8e42ff57a1134630449fd703177d7a12d0c9ced024844dc1b9e0ecad67587dd5c479431b36a1a", + "input_index": 7 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "020611450c6c1944ecdecb78f61816c767fba4368f21f7e9b169779c76f23cf4cc", + "dleq_proof": "4ab36bdd69eb1cd0d4b0aeae403dce4db5228c5ba3a291dc725de23382d1736d265d7bc33f83690a5ca5609719f19e81952d4c8d5e288fd0cb8c6411104b80a3", + "input_index": 7 + }, + { + "scan_key": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28", + "ecdh_share": "02fa1ced932598a27fa28410b955ea67479b5a4033b69f2c99e4e26767bba0a556", + "dleq_proof": "a0948c517d70976c0e39ca67abf19e7217040dbe172bb96534133e6ffa3941c1659416f540662b7561efb70064b4d71a9b17b63bc563f630db4422f273e0df12", + "input_index": 8 + }, + { + "scan_key": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510", + "ecdh_share": "02f3c175b08b207637616aa74e67baac1a1807c94bce70800f76f5b17b52c0082d", + "dleq_proof": "99225658fede7a8c2437eb3821bdc9d3700abc896e8b6dcef84e29347b78bc2b03e6da33836e4f40767390c36644ce016b36b1d546963540fa51d0b0407db6d7", + "input_index": 8 + }, + { + "scan_key": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c", + "ecdh_share": "0300e0fd1710dc56ad7c173aa9141d731577009bc3dffcba8576a48e77ab34d970", + "dleq_proof": "ee0aaa65ca73ccc547b31c2b7ed2ae31a4f4ccdaea73f2add24630d608ede9aea5d808688186ebca42b877efab13f35e60f210d4f620602f850fc0731c201e91", + "input_index": 8 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 30000, + "sp_v0_info": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd4", + "script": "5120d03a55cbe96eea0b8355c8fc99f707cd3b80adb12f2754abdac71aeaada96f9a" + }, + { + "output_index": 1, + "amount": 30000, + "sp_v0_info": "033361d3ff72f34e6b4e7a7bef96e5b8151e66a979adce753c39c583cbe5766d28031266581e3e841cbb94de62ea735583a232c4c888fa6edef2ec2f870789fc1dd4", + "script": "5120d0bf855f85a8e46e4bbc37a4837700aed7236b16f85922267e3f77e877cf7211" + }, + { + "output_index": 2, + "amount": 20000, + "sp_v0_info": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e", + "script": "51200ca53ca247b1503e2e652ffba596b93107e3974c40781e86dfb511303c3bd975" + }, + { + "output_index": 3, + "amount": 20000, + "sp_v0_info": "02a9f1fac2cc457684f33de90073fe20d22c947c92163b862b14d0aba1df471510024a48d76e20d40bcf5f2e1a5c3ffeb3dc2a8b3b88d79a486d54c9d9eaa8fa188e", + "script": "512030527f0182b066f00413c168fe7fee9881037241bc198a6ea302c99c05246bbc" + }, + { + "output_index": 4, + "amount": 10000, + "sp_v0_info": "038ed3220e73344f91e2d33391e3e1691db39daf06e4237e197ed0d007bf27286c03f81473844c9d74c921ff17a5af410b6337348d7afbff73891bc5cb0cb24cb0c0", + "script": "512036252182606f28f595a1aac66e1a81d19ca5a8cb7550447dc5ea6bf238cfda46" + }, + { + "output_index": 5, + "amount": 50000, + "script": "51206fc506f8052a9f5a8aa9b990d5e994f495dded6d47bac44caacdadd8d8991cd0" + } + ], + "task": "sign" + } + } + ], + "workflows": [ + { + "psbt": "", + "description": "Single-input P2WPKH to silent payment workflow (global-share): Creator adds inputs and SP outputs", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "create" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEDAfsEAgAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEDCJBfAQAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEDAfsEAgAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEDCJBfAQAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "description": "Single-input P2WPKH to silent payment workflow (global-share): Updater adds UTXO and BIP32 derivation data", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "update" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "2d47cf80e00e3e84a6abf8c0e92a13a4d4a801477d6182ee8a0894fc7310d69c" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Single-input P2WPKH to silent payment workflow (global-share): Signer adds the ECDH shares and DLEQ proofs, computes the silent payment output scripts, signs every eligible input", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "2430479d2da1310a024d2aab8e4c7b49d76cd51f45ee8127c159b0393a675b6f75c581ebe3d0817ddaf3bb598cfd7a022f1a87ed479664f6b947a47db5941cb2" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159" + } + ], + "task": "sign" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/RzBEAiBsUXWzNsRgJ+KIrLp6hD/D+7IjXuBy8qdtA243LRJHDQIgG90CSaAJn3T2lLX/VuXnXyUXH1W9g8bow/+au5wF5YgBIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABBCJRIGRvSUygu5vOrRS4235MaURWH68jLnzMw2vdWGlfdJFZAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "transaction_id": "2d47cf80e00e3e84a6abf8c0e92a13a4d4a801477d6182ee8a0894fc7310d69c" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOyICAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/RzBEAiBsUXWzNsRgJ+KIrLp6hD/D+7IjXuBy8qdtA243LRJHDQIgG90CSaAJn3T2lLX/VuXnXyUXH1W9g8bow/+au5wF5YgBIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQMIkF8BAAAAAAABBCJRIGRvSUygu5vOrRS4235MaURWH68jLnzMw2vdWGlfdJFZAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "description": "Single-input P2WPKH to silent payment workflow (global-share): Input Finalizer builds the final scriptwitness", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "signed": true + } + ], + "task": "finalize" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIawJHMEQCIGxRdbM2xGAn4oisunqEP8P7siNe4HLyp20DbjctEkcNAiAb3QJJoAmfdPaUtf9W5edfJRcfVb2DxujD/5q7nAXliAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "2d47cf80e00e3e84a6abf8c0e92a13a4d4a801477d6182ee8a0894fc7310d69c" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIawJHMEQCIGxRdbM2xGAn4oisunqEP8P7siNe4HLyp20DbjctEkcNAiAb3QJJoAmfdPaUtf9W5edfJRcfVb2DxujD/5q7nAXliAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Single-input P2WPKH to silent payment workflow (global-share): Extractor produces the raw transaction", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "2430479d2da1310a024d2aab8e4c7b49d76cd51f45ee8127c159b0393a675b6f75c581ebe3d0817ddaf3bb598cfd7a022f1a87ed479664f6b947a47db5941cb2" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 90000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "5120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f749159" + } + ], + "task": "extract" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAQEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA+yk/xG3KOLg9gzmIilDpv9VudlfYnv5qZ0IS8hy1QpbIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAJDBHnS2hMQoCTSqrjkx7Sdds1R9F7oEnwVmwOTpnW291xYHr49CBfdrzu1mM/XoCLxqH7UeWZPa5R6R9tZQcsgH7BAIAAAAAAQEfoIYBAAAAAAAWABQeKteHLTKUE6Vt8JaL4zgiJ4MWOwEIawJHMEQCIGxRdbM2xGAn4oisunqEP8P7siNe4HLyp20DbjctEkcNAiAb3QJJoAmfdPaUtf9W5edfJRcfVb2DxujD/5q7nAXliAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///wABAwiQXwEAAAAAAAEEIlEgZG9JTKC7m86tFLjbfkxpRFYfryMufMzDa91YaV90kVkBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "2d47cf80e00e3e84a6abf8c0e92a13a4d4a801477d6182ee8a0894fc7310d69c", + "tx": "02000000000101f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb710000000000feffffff01905f010000000000225120646f494ca0bb9bcead14b8db7e4c6944561faf232e7cccc36bdd58695f7491590247304402206c5175b336c46027e288acba7a843fc3fbb2235ee072f2a76d036e372d12470d02201bdd0249a0099f74f694b5ff56e5e75f25171f55bd83c6e8c3ff9abb9c05e588012102c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf00000000" + } + }, + { + "psbt": "", + "description": "Two-input P2WPKH to silent payment workflow (global-share): Creator adds inputs and SP outputs", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "prevout_txid": "8a25311a31ffee9c3bba9c5955c092854f29082424e088f75bc1f336413a6e8e", + "prevout_index": 0, + "sequence": 4294967294 + }, + { + "input_index": 1, + "prevout_txid": "951fde6f1ce3a7c3f3e18cdabc16dae3b20c48e4485d300e9a41630e36e88341", + "prevout_index": 0, + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "create" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABDiCObjpBNvPBW/eI4CQkCClPhZLAVVmcujuc7v8xGjEligEPBAAAAAABEAT+////AAEOIEGD6DYOY0GaDjBdSORIDLLj2ha82ozh88On4xxv3h+VAQ8EAAAAAAEQBP7///8AAQMIMOYCAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABDiCObjpBNvPBW/eI4CQkCClPhZLAVVmcujuc7v8xGjEligEPBAAAAAABEAT+////AAEOIEGD6DYOY0GaDjBdSORIDLLj2ha82ozh88On4xxv3h+VAQ8EAAAAAAEQBP7///8AAQMIMOYCAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Two-input P2WPKH to silent payment workflow (global-share): Updater adds UTXO and BIP32 derivation data", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba47", + "prevout_txid": "8a25311a31ffee9c3bba9c5955c092854f29082424e088f75bc1f336413a6e8e", + "prevout_index": 0, + "amount": 100000, + "witness_utxo": "a0860100000000001600147d9d0b2a960148f30818e0675642e2d980c25848", + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600147d9d0b2a960148f30818e0675642e2d980c2584800000000", + "sequence": 4294967294 + }, + { + "input_index": 1, + "public_key": "034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba47", + "prevout_txid": "951fde6f1ce3a7c3f3e18cdabc16dae3b20c48e4485d300e9a41630e36e88341", + "prevout_index": 0, + "amount": 100000, + "witness_utxo": "a0860100000000001600147d9d0b2a960148f30818e0675642e2d980c25848", + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a0860100000000001600147d9d0b2a960148f30818e0675642e2d980c2584800000000", + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "update" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFH2dCyqWAUjzCBjgZ1ZC4tmAwlhIIgYDS/S+VPtuUSyQGW5Op8XYIGX/ZV8bKgzw4BVHcA4XukcEAAAAAAEOII5uOkE288Fb94jgJCQIKU+FksBVWZy6O5zu/zEaMSWKAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSCIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiBBg+g2DmNBmg4wXUjkSAyy49oWvNqM4fPDp+Mcb94flQEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "transaction_id": "84829d16efc058a87d70e7019e4e2dba1ad1c1219281ae832c4bbf01563a84c2" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFH2dCyqWAUjzCBjgZ1ZC4tmAwlhIIgYDS/S+VPtuUSyQGW5Op8XYIGX/ZV8bKgzw4BVHcA4XukcEAAAAAAEOII5uOkE288Fb94jgJCQIKU+FksBVWZy6O5zu/zEaMSWKAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSCIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiBBg+g2DmNBmg4wXUjkSAyy49oWvNqM4fPDp+Mcb94flQEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "description": "Two-input P2WPKH to silent payment workflow (global-share): Signer adds the ECDH shares and DLEQ proofs, computes the silent payment output scripts, signs every eligible input", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "private_key": "c4e8910372b423ebd097172609721e916b1412ff32b98b19e60bf18fa44bd87e", + "signed": true + }, + { + "input_index": 1, + "private_key": "c4e8910372b423ebd097172609721e916b1412ff32b98b19e60bf18fa44bd87e", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03513411e499892e02665af2c83adb42941793e5c192ae092d02181e851791bdd5", + "dleq_proof": "8a67d919c7ccd7dcbb9a6e576fa8859b0c33d659e5eb30bc6ef843f715730200b9b3e4ad6f240db19d2ab8cf694845d4aa9877f9db9a0b3679226797ae334e6b" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51202d6827c2cc1f1e3df42ba1f199f142c6ba2a7cb96dc5590b869566f56ecddbd2" + } + ], + "task": "sign" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA1E0EeSZiS4CZlryyDrbQpQXk+XBkq4JLQIYHoUXkb3VIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAimfZGcfM19y7mm5Xb6iFmwwz1lnl6zC8bvhD9xVzAgC5s+StbyQNsZ0quM9pSEXUqph3+duaCzZ5ImeXrjNOawH7BAIAAAAAAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSCICA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHSDBFAiEAvkiYI/z3iG3bfyQP/DMNEkcsEyLGGxKvB8y37t5RHFECIHX+VlfLQBgrVxAxZc8rRl2wW2SXj1qqzp96hqcqlp6AASIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiCObjpBNvPBW/eI4CQkCClPhZLAVVmcujuc7v8xGjEligEPBAAAAAABEAT+////AAEBH6CGAQAAAAAAFgAUfZ0LKpYBSPMIGOBnVkLi2YDCWEgiAgNL9L5U+25RLJAZbk6nxdggZf9lXxsqDPDgFUdwDhe6R0cwRAIgfkLMlyca1RYKOJwamqjbfFapmpQXJBa3zpxHM0VRoJECIG/UbJV9vWy3sL09SjeIaeHOkgzhsMJbtIFw/Yx6lwW6ASIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiBBg+g2DmNBmg4wXUjkSAyy49oWvNqM4fPDp+Mcb94flQEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQQiUSAtaCfCzB8ePfQrofGZ8ULGuip8uW3FWQuGlWb1bs3b0gEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "transaction_id": "84829d16efc058a87d70e7019e4e2dba1ad1c1219281ae832c4bbf01563a84c2" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA1E0EeSZiS4CZlryyDrbQpQXk+XBkq4JLQIYHoUXkb3VIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAimfZGcfM19y7mm5Xb6iFmwwz1lnl6zC8bvhD9xVzAgC5s+StbyQNsZ0quM9pSEXUqph3+duaCzZ5ImeXrjNOawH7BAIAAAAAAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSCICA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHSDBFAiEAvkiYI/z3iG3bfyQP/DMNEkcsEyLGGxKvB8y37t5RHFECIHX+VlfLQBgrVxAxZc8rRl2wW2SXj1qqzp96hqcqlp6AASIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiCObjpBNvPBW/eI4CQkCClPhZLAVVmcujuc7v8xGjEligEPBAAAAAABEAT+////AAEBH6CGAQAAAAAAFgAUfZ0LKpYBSPMIGOBnVkLi2YDCWEgiAgNL9L5U+25RLJAZbk6nxdggZf9lXxsqDPDgFUdwDhe6R0cwRAIgfkLMlyca1RYKOJwamqjbfFapmpQXJBa3zpxHM0VRoJECIG/UbJV9vWy3sL09SjeIaeHOkgzhsMJbtIFw/Yx6lwW6ASIGA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHBAAAAAABDiBBg+g2DmNBmg4wXUjkSAyy49oWvNqM4fPDp+Mcb94flQEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQQiUSAtaCfCzB8ePfQrofGZ8ULGuip8uW3FWQuGlWb1bs3b0gEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "description": "Two-input P2WPKH to silent payment workflow (global-share): Input Finalizer builds the final scriptwitness", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "signed": true + }, + { + "input_index": 1, + "signed": true + } + ], + "task": "finalize" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA1E0EeSZiS4CZlryyDrbQpQXk+XBkq4JLQIYHoUXkb3VIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAimfZGcfM19y7mm5Xb6iFmwwz1lnl6zC8bvhD9xVzAgC5s+StbyQNsZ0quM9pSEXUqph3+duaCzZ5ImeXrjNOawH7BAIAAAAAAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIbAJIMEUCIQC+SJgj/PeIbdt/JA/8Mw0SRywTIsYbEq8HzLfu3lEcUQIgdf5WV8tAGCtXEDFlzytGXbBbZJePWqrOn3qGpyqWnoABIQNL9L5U+25RLJAZbk6nxdggZf9lXxsqDPDgFUdwDhe6RwEOII5uOkE288Fb94jgJCQIKU+FksBVWZy6O5zu/zEaMSWKAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIawJHMEQCIH5CzJcnGtUWCjicGpqo23xWqZqUFyQWt86cRzNFUaCRAiBv1GyVfb1st7C9PUo3iGnhzpIM4bDCW7SBcP2MepcFugEhA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHAQ4gQYPoNg5jQZoOMF1I5EgMsuPaFrzajOHzw6fjHG/eH5UBDwQAAAAAARAE/v///wABAwgw5gIAAAAAAAEEIlEgLWgnwswfHj30K6HxmfFCxroqfLltxVkLhpVm9W7N29IBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "84829d16efc058a87d70e7019e4e2dba1ad1c1219281ae832c4bbf01563a84c2" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA1E0EeSZiS4CZlryyDrbQpQXk+XBkq4JLQIYHoUXkb3VIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAimfZGcfM19y7mm5Xb6iFmwwz1lnl6zC8bvhD9xVzAgC5s+StbyQNsZ0quM9pSEXUqph3+duaCzZ5ImeXrjNOawH7BAIAAAAAAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIbAJIMEUCIQC+SJgj/PeIbdt/JA/8Mw0SRywTIsYbEq8HzLfu3lEcUQIgdf5WV8tAGCtXEDFlzytGXbBbZJePWqrOn3qGpyqWnoABIQNL9L5U+25RLJAZbk6nxdggZf9lXxsqDPDgFUdwDhe6RwEOII5uOkE288Fb94jgJCQIKU+FksBVWZy6O5zu/zEaMSWKAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIawJHMEQCIH5CzJcnGtUWCjicGpqo23xWqZqUFyQWt86cRzNFUaCRAiBv1GyVfb1st7C9PUo3iGnhzpIM4bDCW7SBcP2MepcFugEhA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHAQ4gQYPoNg5jQZoOMF1I5EgMsuPaFrzajOHzw6fjHG/eH5UBDwQAAAAAARAE/v///wABAwgw5gIAAAAAAAEEIlEgLWgnwswfHj30K6HxmfFCxroqfLltxVkLhpVm9W7N29IBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Two-input P2WPKH to silent payment workflow (global-share): Extractor produces the raw transaction", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba47", + "signed": true + }, + { + "input_index": 1, + "public_key": "034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba47", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03513411e499892e02665af2c83adb42941793e5c192ae092d02181e851791bdd5", + "dleq_proof": "8a67d919c7ccd7dcbb9a6e576fa8859b0c33d659e5eb30bc6ef843f715730200b9b3e4ad6f240db19d2ab8cf694845d4aa9877f9db9a0b3679226797ae334e6b" + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "51202d6827c2cc1f1e3df42ba1f199f142c6ba2a7cb96dc5590b869566f56ecddbd2" + } + ], + "task": "extract" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAIgcCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghA1E0EeSZiS4CZlryyDrbQpQXk+XBkq4JLQIYHoUXkb3VIggCekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAimfZGcfM19y7mm5Xb6iFmwwz1lnl6zC8bvhD9xVzAgC5s+StbyQNsZ0quM9pSEXUqph3+duaCzZ5ImeXrjNOawH7BAIAAAAAAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIbAJIMEUCIQC+SJgj/PeIbdt/JA/8Mw0SRywTIsYbEq8HzLfu3lEcUQIgdf5WV8tAGCtXEDFlzytGXbBbZJePWqrOn3qGpyqWnoABIQNL9L5U+25RLJAZbk6nxdggZf9lXxsqDPDgFUdwDhe6RwEOII5uOkE288Fb94jgJCQIKU+FksBVWZy6O5zu/zEaMSWKAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABR9nQsqlgFI8wgY4GdWQuLZgMJYSAEIawJHMEQCIH5CzJcnGtUWCjicGpqo23xWqZqUFyQWt86cRzNFUaCRAiBv1GyVfb1st7C9PUo3iGnhzpIM4bDCW7SBcP2MepcFugEhA0v0vlT7blEskBluTqfF2CBl/2VfGyoM8OAVR3AOF7pHAQ4gQYPoNg5jQZoOMF1I5EgMsuPaFrzajOHzw6fjHG/eH5UBDwQAAAAAARAE/v///wABAwgw5gIAAAAAAAEEIlEgLWgnwswfHj30K6HxmfFCxroqfLltxVkLhpVm9W7N29IBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "84829d16efc058a87d70e7019e4e2dba1ad1c1219281ae832c4bbf01563a84c2", + "tx": "020000000001028e6e3a4136f3c15bf788e0242408294f8592c055599cba3b9ceeff311a31258a0000000000feffffff4183e8360e63419a0e305d48e4480cb2e3da16bcda8ce1f3c3a7e31c6fde1f950000000000feffffff0130e60200000000002251202d6827c2cc1f1e3df42ba1f199f142c6ba2a7cb96dc5590b869566f56ecddbd202483045022100be489823fcf7886ddb7f240ffc330d12472c1322c61b12af07ccb7eede511c51022075fe5657cb40182b57103165cf2b465db05b64978f5aaace9f7a86a72a969e800121034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba470247304402207e42cc97271ad5160a389c1a9aa8db7c56a99a94172416b7ce9c47334551a09102206fd46c957dbd6cb7b0bd3d4a378869e1ce920ce1b0c25bb48170fd8c7a9705ba0121034bf4be54fb6e512c90196e4ea7c5d82065ff655f1b2a0cf0e01547700e17ba4700000000" + } + }, + { + "psbt": "", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Creator adds inputs and SP outputs", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "sequence": 4294967294 + }, + { + "input_index": 1, + "prevout_txid": "26d393ed2bc842fef499962be79f9d6c4c19b22d83a16334d125cb09a785d4bc", + "prevout_index": 0, + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "create" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEOILzUhacJyyXRNGOhgy2yGUxsnZ/nK5aZ9P5CyCvtk9MmAQ8EAAAAAAEQBP7///8AAQMIMOYCAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABDiD3Tt0fdbS7Pl10nBW/22Y0j2gFqbTUX+7houIB9QO7cQEPBAAAAAABEAT+////AAEOILzUhacJyyXRNGOhgy2yGUxsnZ/nK5aZ9P5CyCvtk9MmAQ8EAAAAAAEQBP7///8AAQMIMOYCAAAAAAABCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Updater adds UTXO and BIP32 derivation data", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "prevout_txid": "71bb03f501e2a2e1ee5fd4b4a905688f3466dbbf159c745d3ebbb4751fdd4ef7", + "prevout_index": 0, + "amount": 100000, + "witness_utxo": "a0860100000000001600141e2ad7872d329413a56df0968be338222783163b", + "non_witness_utxo": "020000000118a717663b0bab14b12a1a771323ff1e4079dd532e5dd13e28ea1081c700984a0000000000ffffffff01a0860100000000001600141e2ad7872d329413a56df0968be338222783163b00000000", + "sequence": 4294967294 + }, + { + "input_index": 1, + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "prevout_txid": "26d393ed2bc842fef499962be79f9d6c4c19b22d83a16334d125cb09a785d4bc", + "prevout_index": 0, + "amount": 100000, + "witness_utxo": "a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e", + "non_witness_utxo": "0200000001be9d65c83915fb09248abbdfca8ca3eee6ce350c554f65e8d526e5df527ab5220000000000ffffffff01a086010000000000160014a692511c079575bf3756dabc56ad71d4284a690e00000000", + "sequence": 4294967294 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "update" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDiIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8AAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDiIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////AAEDCDDmAgAAAAAAAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Signer adds its ECDH share and DLEQ proof, wait for every eligible input to have a share before signing (signer 1 of 2)", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "signed": false + }, + { + "input_index": 1, + "private_key": "", + "signed": false + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039" + } + ], + "task": "sign" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iBgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AQAAAAAAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///wABAwgw5gIAAAAAAAEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEDAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iBgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3AQAAAAAAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///wABAwgw5gIAAAAAAAEJQgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaANh4bHp3l5CyyAH98pUueDVftE5OPrVbT8Z5XUTqPzgOQA=", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Signer adds its ECDH share and DLEQ proof, verifies other DLEQ proofs, computes the silent payment output scripts, signs its input (signer 2 of 2)", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "private_key": "", + "signed": false + }, + { + "input_index": 1, + "private_key": "295c2eedddd8331d20b5d4cf9e69bb523ed85cb0bf35ab12e04fea66fe6d4a4a", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + }, + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "0334d2cef74eded4464227607fc59ac1de80c12a2433a56271528edccf50fa6c2b", + "dleq_proof": "37c00c0b42a073f6b65f0c4b6e56e06774b380c1df3de28b640b121ee0b3b4cf7850df456e0b5d8e1975ddff25262c8381e20f852cd870bde3f6a832a6325bcc", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b" + } + ], + "task": "sign" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iAgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3EcwRAIgUhzoeWdBqUYJL1sZIfeJAIknoDIy0at07Y3Rq7QK4MgCIDLIptv0hMsZvoLDPyhGHLIYZ2dfkC6SuH6OoTmjTPOKASIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAzTSzvdO3tRGQidgf8Wawd6AwSokM6VicVKO3M9Q+mwrIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAN8AMC0Kgc/a2XwxLblbgZ3SzgMHfPeKLZAsSHuCztM94UN9Fbgtdjhl13f8lJiyDgeIPhSzYcL3j9qgypjJbzAABAwgw5gIAAAAAAAEEIlEgmbvSmC8CgLzcJkMdaynPZ5EYpbu7YJFNb/rPq7xctFsBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iAgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3EcwRAIgUhzoeWdBqUYJL1sZIfeJAIknoDIy0at07Y3Rq7QK4MgCIDLIptv0hMsZvoLDPyhGHLIYZ2dfkC6SuH6OoTmjTPOKASIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAzTSzvdO3tRGQidgf8Wawd6AwSokM6VicVKO3M9Q+mwrIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAN8AMC0Kgc/a2XwxLblbgZ3SzgMHfPeKLZAsSHuCztM94UN9Fbgtdjhl13f8lJiyDgeIPhSzYcL3j9qgypjJbzAABAwgw5gIAAAAAAAEEIlEgmbvSmC8CgLzcJkMdaynPZ5EYpbu7YJFNb/rPq7xctFsBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Signer verifies the DLEQ proofs and the output scripts, signs its input (signer 1 of 2)", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "private_key": "7e31eeeb1aa2597b6d63b357541461d75ddae76b7603d24619f5ebed9e88ec31", + "signed": true + }, + { + "input_index": 1, + "private_key": "", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + }, + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "0334d2cef74eded4464227607fc59ac1de80c12a2433a56271528edccf50fa6c2b", + "dleq_proof": "37c00c0b42a073f6b65f0c4b6e56e06774b380c1df3de28b640b121ee0b3b4cf7850df456e0b5d8e1975ddff25262c8381e20f852cd870bde3f6a832a6325bcc", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b" + } + ], + "task": "sign" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCfetqsTkKw9GZkiMqZ26PUoDEWXN1Q7oX2MZzjZNsurQIgctYOTZ5kP6lh1c4+MmiOAp+oKltTvCpXtC845ccWf8ABIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iAgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3EcwRAIgUhzoeWdBqUYJL1sZIfeJAIknoDIy0at07Y3Rq7QK4MgCIDLIptv0hMsZvoLDPyhGHLIYZ2dfkC6SuH6OoTmjTPOKASIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAzTSzvdO3tRGQidgf8Wawd6AwSokM6VicVKO3M9Q+mwrIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAN8AMC0Kgc/a2XwxLblbgZ3SzgMHfPeKLZAsSHuCztM94UN9Fbgtdjhl13f8lJiyDgeIPhSzYcL3j9qgypjJbzAABAwgw5gIAAAAAAAEEIlEgmbvSmC8CgLzcJkMdaynPZ5EYpbu7YJFNb/rPq7xctFsBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7IgICyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL9IMEUCIQCfetqsTkKw9GZkiMqZ26PUoDEWXN1Q7oX2MZzjZNsurQIgctYOTZ5kP6lh1c4+MmiOAp+oKltTvCpXtC845ccWf8ABIgYCyBe7dSGvw16pbzv7Jw5utQ3f+lVgYnuWH+wA8pllCL8EAAAAAAEOIPdO3R91tLs+XXScFb/bZjSPaAWptNRf7uGi4gH1A7txAQ8EAAAAAAEQBP7///8iHQJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaCED7KT/Ebco4uD2DOYiKUOm/1W52V9ie/mpnQhLyHLVClsiHgJ6SH/Bn7dph3uHQtbqGBGPPE5yseqMbeYCp61KQdvgaECKE7OYVUX3K9bolxSuuQmz41SoQqm7i1bNDt7SHfihmVmLMSKKSeC9fpXOEFP3xbKKy1Q6aHB2AOPOiYIu4yAhAAEBH6CGAQAAAAAAFgAUppJRHAeVdb83Vtq8Vq1x1ChKaQ4iAgL1tZ+l5JIiHr9VunitRCYFvq6VFmuh66MlDQu6rH4u3EcwRAIgUhzoeWdBqUYJL1sZIfeJAIknoDIy0at07Y3Rq7QK4MgCIDLIptv0hMsZvoLDPyhGHLIYZ2dfkC6SuH6OoTmjTPOKASIGAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cBAAAAAABDiC81IWnCcsl0TRjoYMtshlMbJ2f5yuWmfT+Qsgr7ZPTJgEPBAAAAAABEAT+////Ih0Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GghAzTSzvdO3tRGQidgf8Wawd6AwSokM6VicVKO3M9Q+mwrIh4Cekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GhAN8AMC0Kgc/a2XwxLblbgZ3SzgMHfPeKLZAsSHuCztM94UN9Fbgtdjhl13f8lJiyDgeIPhSzYcL3j9qgypjJbzAABAwgw5gIAAAAAAAEEIlEgmbvSmC8CgLzcJkMdaynPZ5EYpbu7YJFNb/rPq7xctFsBCUICekh/wZ+3aYd7h0LW6hgRjzxOcrHqjG3mAqetSkHb4GgDYeGx6d5eQssgB/fKVLng1X7ROTj61W0/GeV1E6j84DkA", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Input Finalizer builds the final scriptwitness", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "signed": true + }, + { + "input_index": 1, + "signed": true + } + ], + "task": "finalize" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAJ962qxOQrD0ZmSIypnbo9SgMRZc3VDuhfYxnONk2y6tAiBy1g5NnmQ/qWHVzj4yaI4Cn6gqW1O8Kle0LzjlxxZ/wAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIawJHMEQCIFIc6HlnQalGCS9bGSH3iQCJJ6AyMtGrdO2N0au0CuDIAiAyyKbb9ITLGb6Cwz8oRhyyGGdnX5Aukrh+jqE5o0zzigEhAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQM00s73Tt7URkInYH/FmsHegMEqJDOlYnFSjtzPUPpsKyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQDfADAtCoHP2tl8MS25W4Gd0s4DB3z3ii2QLEh7gs7TPeFDfRW4LXY4Zdd3/JSYsg4HiD4Us2HC94/aoMqYyW8wAAQMIMOYCAAAAAAABBCJRIJm70pgvAoC83CZDHWspz2eRGKW7u2CRTW/6z6u8XLRbAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090" + } + }, + { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAJ962qxOQrD0ZmSIypnbo9SgMRZc3VDuhfYxnONk2y6tAiBy1g5NnmQ/qWHVzj4yaI4Cn6gqW1O8Kle0LzjlxxZ/wAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIawJHMEQCIFIc6HlnQalGCS9bGSH3iQCJJ6AyMtGrdO2N0au0CuDIAiAyyKbb9ITLGb6Cwz8oRhyyGGdnX5Aukrh+jqE5o0zzigEhAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQM00s73Tt7URkInYH/FmsHegMEqJDOlYnFSjtzPUPpsKyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQDfADAtCoHP2tl8MS25W4Gd0s4DB3z3ii2QLEh7gs7TPeFDfRW4LXY4Zdd3/JSYsg4HiD4Us2HC94/aoMqYyW8wAAQMIMOYCAAAAAAABBCJRIJm70pgvAoC83CZDHWspz2eRGKW7u2CRTW/6z6u8XLRbAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "description": "Two-input P2WPKH to silent payment workflow (per-input-share): Extractor produces the raw transaction", + "supplementary": { + "inputs": [ + { + "input_index": 0, + "public_key": "02c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf", + "signed": true + }, + { + "input_index": 1, + "public_key": "02f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc", + "signed": true + } + ], + "sp_proofs": [ + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "03eca4ff11b728e2e0f60ce6222943a6ff55b9d95f627bf9a99d084bc872d50a5b", + "dleq_proof": "8a13b3985545f72bd6e89714aeb909b3e354a842a9bb8b56cd0eded21df8a199598b31228a49e0bd7e95ce1053f7c5b28acb543a68707600e3ce89822ee32021", + "input_index": 0 + }, + { + "scan_key": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe068", + "ecdh_share": "0334d2cef74eded4464227607fc59ac1de80c12a2433a56271528edccf50fa6c2b", + "dleq_proof": "37c00c0b42a073f6b65f0c4b6e56e06774b380c1df3de28b640b121ee0b3b4cf7850df456e0b5d8e1975ddff25262c8381e20f852cd870bde3f6a832a6325bcc", + "input_index": 1 + } + ], + "outputs": [ + { + "output_index": 0, + "amount": 190000, + "sp_v0_info": "027a487fc19fb769877b8742d6ea18118f3c4e72b1ea8c6de602a7ad4a41dbe0680361e1b1e9de5e42cb2007f7ca54b9e0d57ed13938fad56d3f19e57513a8fce039", + "script": "512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b" + } + ], + "task": "extract" + }, + "expected": { + "psbt": "cHNidP8BAgQCAAAAAQQBAgEFAQEBBgEAAfsEAgAAAAABAR+ghgEAAAAAABYAFB4q14ctMpQTpW3wlovjOCIngxY7AQhsAkgwRQIhAJ962qxOQrD0ZmSIypnbo9SgMRZc3VDuhfYxnONk2y6tAiBy1g5NnmQ/qWHVzj4yaI4Cn6gqW1O8Kle0LzjlxxZ/wAEhAsgXu3Uhr8NeqW87+ycObrUN3/pVYGJ7lh/sAPKZZQi/AQ4g907dH3W0uz5ddJwVv9tmNI9oBam01F/u4aLiAfUDu3EBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQPspP8Rtyji4PYM5iIpQ6b/VbnZX2J7+amdCEvIctUKWyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQIoTs5hVRfcr1uiXFK65CbPjVKhCqbuLVs0O3tId+KGZWYsxIopJ4L1+lc4QU/fFsorLVDpocHYA486Jgi7jICEAAQEfoIYBAAAAAAAWABSmklEcB5V1vzdW2rxWrXHUKEppDgEIawJHMEQCIFIc6HlnQalGCS9bGSH3iQCJJ6AyMtGrdO2N0au0CuDIAiAyyKbb9ITLGb6Cwz8oRhyyGGdnX5Aukrh+jqE5o0zzigEhAvW1n6XkkiIev1W6eK1EJgW+rpUWa6HroyUNC7qsfi7cAQ4gvNSFpwnLJdE0Y6GDLbIZTGydn+crlpn0/kLIK+2T0yYBDwQAAAAAARAE/v///yIdAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoIQM00s73Tt7URkInYH/FmsHegMEqJDOlYnFSjtzPUPpsKyIeAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoQDfADAtCoHP2tl8MS25W4Gd0s4DB3z3ii2QLEh7gs7TPeFDfRW4LXY4Zdd3/JSYsg4HiD4Us2HC94/aoMqYyW8wAAQMIMOYCAAAAAAABBCJRIJm70pgvAoC83CZDHWspz2eRGKW7u2CRTW/6z6u8XLRbAQlCAnpIf8Gft2mHe4dC1uoYEY88TnKx6oxt5gKnrUpB2+BoA2HhseneXkLLIAf3ylS54NV+0Tk4+tVtPxnldROo/OA5AA==", + "transaction_id": "29b18471f7e65606a519a7b2154c5d875ba3e24a6234a76483d66eeaf99ed090", + "tx": "02000000000102f74edd1f75b4bb3e5d749c15bfdb66348f6805a9b4d45feee1a2e201f503bb710000000000feffffffbcd485a709cb25d13463a1832db2194c6c9d9fe72b9699f4fe42c82bed93d3260000000000feffffff0130e602000000000022512099bbd2982f0280bcdc26431d6b29cf679118a5bbbb60914d6ffacfabbc5cb45b024830450221009f7adaac4e42b0f4666488ca99dba3d4a031165cdd50ee85f6319ce364db2ead022072d60e4d9e643fa961d5ce3e32688e029fa82a5b53bc2a57b42f38e5c7167fc0012102c817bb7521afc35ea96f3bfb270e6eb50ddffa5560627b961fec00f2996508bf024730440220521ce8796741a946092f5b1921f789008927a03232d1ab74ed8dd1abb40ae0c8022032c8a6dbf484cb19be82c33f28461cb21867675f902e92b87e8ea139a34cf38a012102f5b59fa5e492221ebf55ba78ad442605beae95166ba1eba3250d0bbaac7e2edc00000000" + } + } + ] +} \ No newline at end of file diff --git a/psbt/tests/bip375_vectors.rs b/psbt/tests/bip375_vectors.rs new file mode 100644 index 00000000..6250e81f --- /dev/null +++ b/psbt/tests/bip375_vectors.rs @@ -0,0 +1,216 @@ +//! Consolidated BIP-375 vector coverage at the PSBT/SPDK boundary. +//! +//! Upstream `rust-psbt` is treated as the parse boundary. SPDK is responsible for share placement +//! semantics and silent payment output derivation. + +use std::fs; +use std::path::PathBuf; + +use bitcoin::base64::prelude::{BASE64_STANDARD, Engine as _}; +use psbt::roles::SpSignerExt; +use psbt_v2::{Psbt, SilentPaymentState}; +use secp256k1::Secp256k1; +use serde::Deserialize; + +#[derive(Debug, Deserialize)] +struct TestVectors { + valid: Vec, + invalid: Vec, +} + +#[derive(Debug, Deserialize)] +struct TestVector { + description: String, + psbt: String, + supplementary: Supplementary, +} + +/// Declared expected outcome for a vector. This is the single source of truth that drives +/// dispatch, mirroring the upstream `rust-psbt` harness. The `valid` / `invalid` array a vector +/// lives in is cross-checked against the task but is not itself the oracle. +#[derive(Debug, Deserialize, PartialEq)] +#[serde(rename_all = "snake_case")] +enum Task { + Sign, + Finalize, + FailSign, + FailDeserialize, +} + +#[derive(Debug, Deserialize)] +struct Supplementary { + task: Task, +} + +type VectorResult = Result, String>; + +fn vectors_path() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/bip375_test_vectors.json") +} + +fn load_vectors() -> TestVectors { + let content = fs::read_to_string(vectors_path()).expect("failed to read BIP375 test vectors"); + serde_json::from_str(&content).expect("failed to parse BIP375 test vectors JSON") +} + +fn decode_psbt_base64(base64: &str) -> Vec { + BASE64_STANDARD + .decode(base64) + .expect("BIP375 vector PSBT must be valid base64") +} + +fn parse_psbt(base64: &str) -> Result { + let bytes = decode_psbt_base64(base64); + Psbt::deserialize(&bytes) +} + +fn derive_outputs(psbt: &Psbt) -> Result { + let secp = Secp256k1::new(); + let mut derived = psbt.clone(); + derived + .commit_sp_outputs(&secp) + .map_err(|e| format!("commit_sp_outputs failed: {e}"))?; + Ok(derived) +} + +fn has_unsigned_inputs(psbt: &Psbt) -> bool { + psbt.inputs.iter().any(|input| { + input.partial_sigs.is_empty() + && input.tap_key_sig.is_none() + && input.tap_script_sigs.is_empty() + && input.final_script_sig.is_none() + && input.final_script_witness.is_none() + }) +} + +fn signer_rejection_reason(psbt: &Psbt) -> Option { + if let Err(e) = psbt.silent_payment_signer_checks() { + return Some(format!("psbt.silent_payment_signer_checks rejected => {e}")); + } + + match derive_outputs(psbt) { + Err(e) => Some(e), + Ok(derived) => psbt + .outputs + .iter() + .zip(&derived.outputs) + .any(|(before, after)| { + before.sp_v0_info.is_some() && before.script_pubkey != after.script_pubkey + }) + .then(|| "derived SP script mismatch".to_string()), + } +} + +fn run_finalize(vector: &TestVector) -> VectorResult { + let psbt = parse_psbt(&vector.psbt).expect("valid vector must deserialize through rust-psbt"); + let derived = derive_outputs(&psbt)?; + + let has_script_mismatch = psbt + .outputs + .iter() + .zip(&derived.outputs) + .any(|(before, after)| { + before.sp_v0_info.is_some() && before.script_pubkey != after.script_pubkey + }); + + if has_script_mismatch { + Err("derived SP script mismatch".to_string()) + } else { + Ok(None) + } +} + +fn run_sign(vector: &TestVector) -> VectorResult { + let psbt = parse_psbt(&vector.psbt).expect("valid vector must deserialize through rust-psbt"); + match psbt.silent_payment_signer_checks() { + Ok(SilentPaymentState::Incomplete) => Ok(None), + Ok(SilentPaymentState::Complete) if has_unsigned_inputs(&psbt) => Ok(None), + Ok(SilentPaymentState::Complete) => { + Err("sign task must still have unsigned inputs".to_string()) + } + other => Err(format!( + "sign task must be a valid incomplete state, got {:?}", + other + )), + } +} + +fn run_fail_sign(vector: &TestVector) -> VectorResult { + let psbt = + parse_psbt(&vector.psbt).map_err(|e| format!("fail_sign should parse but did not: {e}"))?; + let Some(reason) = signer_rejection_reason(&psbt) else { + return Err("fail_sign vector parsed but was not rejected by SPDK signer".to_string()); + }; + + Ok(Some(reason)) +} + +fn run_fail_deserialize(vector: &TestVector) -> VectorResult { + match parse_psbt(&vector.psbt) { + Err(e) => Ok(Some(format!("parse failed: {e}"))), + Ok(_) => Err("fail_deserialize task parsed successfully".to_string()), + } +} + +fn task_name(task: &Task) -> &'static str { + match task { + Task::Sign => "sign", + Task::Finalize => "finalize", + Task::FailSign => "fail_sign", + Task::FailDeserialize => "fail_deserialize", + } +} + +fn run_vector(vector: &TestVector) -> VectorResult { + match vector.supplementary.task { + Task::Finalize => run_finalize(vector), + Task::Sign => run_sign(vector), + Task::FailSign => run_fail_sign(vector), + Task::FailDeserialize => run_fail_deserialize(vector), + } +} + +#[test] +fn test_bip375_vectors_match_task() { + let vectors = load_vectors(); + + let show_pass_output = + std::env::args().any(|arg| arg == "--show-output" || arg == "--nocapture"); + let mut failures = Vec::new(); + + for vector in vectors.valid.iter().chain(&vectors.invalid) { + match run_vector(vector) { + Ok(Some(reason)) if show_pass_output => { + println!( + "PASS: {}: {}\n {}", + task_name(&vector.supplementary.task), + vector.description, + reason + ); + } + Ok(None) if show_pass_output => { + println!( + "PASS: {}: {}", + task_name(&vector.supplementary.task), + vector.description + ); + } + Ok(_) => {} + Err(reason) => { + println!( + "FAILED: {}: {}\n {}", + task_name(&vector.supplementary.task), + vector.description, + reason + ); + failures.push(reason); + } + } + } + + assert!( + failures.is_empty(), + "{} BIP-375 vector(s) failed", + failures.len() + ); +} diff --git a/psbt/tests/signer.rs b/psbt/tests/signer.rs new file mode 100644 index 00000000..b1116adc --- /dev/null +++ b/psbt/tests/signer.rs @@ -0,0 +1,956 @@ +//! Integration tests for the signer role. +//! +//! Covers: +//! 1. Regression for `collect_scan_keys` off-by-one (was passing 67-byte array to a 33-byte key +//! parser, making the entire SP path non-functional). +//! 2. Regression for multi-signer skipping non-eligible inputs in `derive_sp_output_scripts`. +//! 3. BIP-352 n-counter correctness: two outputs to the same scan key produce distinct keys. +//! 4. Unit tests for `extract_eligible_input_pubkey` covering all declared script types. +//! 5. Multi-signer `derive_sp_output_scripts` with mixed eligible/non-eligible inputs (regression +//! for the `is_partial` detection bug). +//! 6. `SigningSession::get_silent_payment_sigs` produces a valid Schnorr signature over an SP +//! input. +//! 7. Receiver-verified end-to-end: the recipient can scan the derived SP outputs (single-signer +//! with an SP input, and two-party multi-signer aggregation). + +use std::collections::HashSet; + +use bitcoin::bip32::{DerivationPath, Fingerprint}; +use bitcoin::hashes::Hash; +use bitcoin::key::TapTweak; +use bitcoin::sighash::{Prevouts, SighashCache}; +use bitcoin::{ + Amount, CompressedPublicKey, OutPoint, ScriptBuf, Sequence, Transaction, TxOut, Txid, + XOnlyPublicKey, +}; +use psbt::roles::signer::extract_eligible_input_pubkey; +use psbt::roles::{ShareMode, SpSignerExt}; +use psbt_v2::{ + Constructor, Creator, Extractor, Finalizer, Input, InputsOnlyModifiable, Output, Psbt, Signer, + SpV0Info, +}; +use secp256k1::{Message, Parity, PublicKey, Scalar, Secp256k1, SecretKey, rand}; +use silentpayments::receiving::{Label, Receiver}; +use silentpayments::utils::receiving::PublicTweakData; +use silentpayments::utils::{NUMS_H, OutPoint as SpOutPoint}; +use silentpayments::{Network, SpVersion, TransactionInputs, TransactionSharedSecret}; + +// ── test helpers ────────────────────────────────────────────────────────────── + +fn secp() -> Secp256k1 { + Secp256k1::new() +} + +fn rng() -> rand::rngs::ThreadRng { + rand::thread_rng() +} + +fn sk(byte: u8) -> SecretKey { + SecretKey::from_slice(&[byte; 32]).unwrap() +} + +fn pk(secp: &Secp256k1, byte: u8) -> PublicKey { + sk(byte).public_key(secp) +} + +fn p2wpkh_script(secp: &Secp256k1, secret: &SecretKey) -> ScriptBuf { + let compressed = bitcoin::CompressedPublicKey(secret.public_key(secp)); + ScriptBuf::new_p2wpkh(&compressed.wpubkey_hash()) +} + +fn p2tr_script(secp: &Secp256k1, secret: &SecretKey) -> ScriptBuf { + let (xonly, _) = secret.x_only_public_key(secp); + ScriptBuf::new_p2tr(secp, xonly, None) +} + +/// Build an `Output` with `sp_v0_info` set to `scan_key(33) | spend_key(33)`. +/// `script_pubkey` is left empty — `set_sp_scriptpubkey` will fill it. +fn sp_output(scan: &PublicKey, spend: &PublicKey) -> Output { + let mut output = Output::new(TxOut { + value: Amount::from_sat(10_000), + script_pubkey: ScriptBuf::new(), + }); + output.sp_v0_info = Some(SpV0Info::new( + CompressedPublicKey(*scan), + CompressedPublicKey(*spend), + )); + output +} + +/// Record `txout` as this input's funding output. +/// +/// `previous_txid` is replaced with the txid of a previous transaction that +/// pays `txout` at `spent_output_index`. A witness-only UTXO is not verifiable +/// for non-P2TR spends, so both UTXO forms are set and kept consistent. +/// The txid of the `OutPoint` passed to [`Input::new`] is not preserved. +fn set_verified_funding_utxo(input: &mut Input, txout: TxOut) { + let vout = input.spent_output_index as usize; + let mut output = vec![ + TxOut { + value: Amount::ZERO, + script_pubkey: ScriptBuf::new(), + }; + vout + ]; + output.push(txout.clone()); + let tx = Transaction { + version: bitcoin::transaction::Version::TWO, + lock_time: bitcoin::absolute::LockTime::ZERO, + input: vec![], + output, + }; + input.previous_txid = tx.compute_txid(); + input.witness_utxo = Some(txout); + input.non_witness_utxo = Some(tx); +} + +/// Build a P2WPKH `Input` with a verifiable funding UTXO and `bip32_derivations` +/// populated so that `extract_eligible_input_pubkey` can identify and return the key. +fn p2wpkh_input(secp: &Secp256k1, outpoint: OutPoint, secret: &SecretKey) -> Input { + let public = secret.public_key(secp); + let mut input = Input::new(&outpoint); + input.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: p2wpkh_script(secp, secret), + }, + ); + input.bip32_derivations.insert( + bitcoin::PublicKey::new(public), + (Fingerprint::default(), DerivationPath::default()), + ); + input +} + +fn outpoint(vout: u32) -> OutPoint { + OutPoint::new( + Txid::from_raw_hash(bitcoin::hashes::sha256d::Hash::all_zeros()), + vout, + ) +} + +/// Build a PSBT with the given outputs and inputs via psbt_v2's Creator/Constructor. +fn new_psbt(outputs: Vec, outpoints: Vec) -> Psbt { + let mut constructor = Creator::new().constructor_modifiable(); + for output in outputs { + constructor = constructor.output(output).unwrap(); + } + let psbt = constructor.psbt().unwrap(); + + let mut constructor = Constructor::::new(psbt).unwrap(); + for outpoint in outpoints { + constructor = constructor.input(Input::new(&outpoint)); + } + constructor.psbt().unwrap() +} + +/// Build an SP P2TR `Input`: the funding output key is `spend_sk + tweak·G` (placed +/// directly, without a BIP-341 tweak), with `sp_tweak` and the BIP-376 +/// `sp_spend_bip32_derivations` entry (keyed by the *untweaked* spend key) populated. +fn sp_p2tr_input( + secp: &Secp256k1, + outpoint: OutPoint, + spend_sk: &SecretKey, + tweak: [u8; 32], +) -> Input { + let tweaked = spend_sk + .add_tweak(&Scalar::from_be_bytes(tweak).unwrap()) + .unwrap(); + let (xonly, _) = tweaked.x_only_public_key(secp); + let mut input = Input::new(&outpoint); + input.sequence = Some(Sequence::MAX); + input.witness_utxo = Some(TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()), + }); + input.sp_tweak = Some(tweak); + input.sp_spend_bip32_derivations.insert( + CompressedPublicKey(spend_sk.public_key(secp)), + (Fingerprint::default(), DerivationPath::default()), + ); + input +} + +/// Sign input 0 as a BIP-376 silent payment input and write the signature. +fn sign_sp_input(psbt: Psbt, spend_sk: &SecretKey, secp: &Secp256k1) -> Psbt { + let mut signer = Signer::new(psbt).unwrap(); + let sigs = { + let mut session = signer.session(); + let input = session.signable_input(0).unwrap(); + vec![ + session + .get_silent_payment_sigs(&input, spend_sk, secp) + .unwrap(), + ] + }; + signer.apply(sigs).unwrap() +} + +/// Rebuild the sender-side `TransactionInputs` exactly as `compute_sp_outputs` does. +fn transaction_inputs_for(psbt: &Psbt) -> TransactionInputs { + let mut inputs = TransactionInputs::with_capacity(psbt.global.input_count); + for input in psbt.inputs.iter() { + let outpoint = SpOutPoint::from_txid_and_vout( + &input.previous_txid.to_string(), + input.spent_output_index, + ) + .unwrap(); + let spk = input + .funding_utxo_untrusted() + .unwrap() + .script_pubkey + .to_bytes(); + let pubkey = extract_eligible_input_pubkey(input).unwrap(); + inputs.push(outpoint, spk, pubkey); + } + inputs +} + +/// Receiver-side verification: the recipient holding `scan_sk` must find every SP output +/// of the PSBT via the public tweak data. This is the assertion that distinguishes a +/// *correct* derived output key from merely *a* P2TR key. +fn assert_receiver_scan_finds_outputs( + secp: &Secp256k1, + psbt: &Psbt, + scan_sk: &SecretKey, + spend_pk: &PublicKey, +) { + let inputs = transaction_inputs_for(psbt); + let tweak_data = PublicTweakData::new(secp, &inputs).unwrap(); + let shared_secret = + TransactionSharedSecret::new_from_public_tweak_data(secp, &tweak_data, scan_sk).unwrap(); + let receiver = Receiver::new( + SpVersion::ZERO, + scan_sk.public_key(secp), + *spend_pk, + Label::new(*scan_sk, 0), + Network::Regtest, + ) + .unwrap(); + + let sp_output_keys: Vec = psbt + .outputs + .iter() + .filter(|o| o.sp_v0_info.is_some()) + .map(|o| { + assert!(o.script_pubkey.is_p2tr(), "SP output must be P2TR"); + XOnlyPublicKey::from_slice(&o.script_pubkey.as_bytes()[2..]).unwrap() + }) + .collect(); + assert!(!sp_output_keys.is_empty()); + + let found = receiver + .scan_transaction(&shared_secret, &sp_output_keys) + .unwrap(); + let found_keys: HashSet<&XOnlyPublicKey> = found.values().flat_map(|m| m.keys()).collect(); + for key in &sp_output_keys { + assert!( + found_keys.contains(key), + "receiver must find SP output {key}" + ); + } +} + +// ── 1. Single-signer round-trip ─────────────────────────────────────────────── + +/// Full single-signer flow: share generation → output computation → script assignment. +/// +/// Before the `collect_scan_keys` fix this always errored because `from_slice` was +/// called with all 67 bytes of the address array instead of the 33-byte scan key. +#[test] +fn test_single_signer_e2e() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + assert!(!psbt.global.sp_ecdh_shares.is_empty()); + assert!(!psbt.global.sp_dleq_proofs.is_empty()); + + let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); + assert_eq!(scripts.len(), 1); + + psbt.commit_sp_outputs(&secp).unwrap(); + + let sp_out = psbt + .outputs + .iter() + .find(|o| o.sp_v0_info.is_some()) + .unwrap(); + assert!( + sp_out.script_pubkey.is_p2tr(), + "SP output must be a P2TR scriptPubKey" + ); + + // Stronger than "is P2TR": the recipient must be able to scan the output. + let scan_sk = sk(2); + assert_receiver_scan_finds_outputs(&secp, &psbt, &scan_sk, &spend_pk); +} + +/// A PSBT with no SP outputs must be a no-op: no shares written, no error. +#[test] +fn test_single_signer_no_sp_outputs_is_noop() { + let secp = secp(); + let spend_sk = sk(1); + let regular_out = Output::new(TxOut { + value: Amount::from_sat(9_000), + script_pubkey: p2wpkh_script(&secp, &spend_sk), + }); + + let mut psbt = new_psbt(vec![regular_out], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + let covered = psbt + .add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + assert!( + covered.is_empty() && psbt.global.sp_ecdh_shares.is_empty(), + "no shares expected when there are no SP outputs" + ); +} + +// ── 2. n-counter correctness ────────────────────────────────────────────────── + +/// Two outputs to the same scan key must receive *distinct* output keys, derived +/// with BIP-352 counter n=0 and n=1 respectively. +/// +/// The concrete check is that the two xonly keys in the result Vec differ. +#[test] +fn test_two_outputs_same_scan_key_produce_distinct_keys() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + // Two identical SP addresses in the same PSBT. + let mut psbt = new_psbt( + vec![ + sp_output(&scan_pk, &spend_pk), + sp_output(&scan_pk, &spend_pk), + ], + vec![outpoint(0)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); + + // One index-keyed script per SP output; the two outputs share an address but + // must get distinct keys derived with n=0 and n=1 respectively. + assert_eq!(scripts.len(), 2, "one script per SP output"); + assert_eq!(scripts[0].0, 0); + assert_eq!(scripts[1].0, 1); + assert_ne!( + scripts[0].1, scripts[1].1, + "n=0 and n=1 must be distinct keys" + ); +} + +/// Two outputs to *different* scan keys each get one entry in the result map, +/// and the single-signer produces one global share per scan key. +#[test] +fn test_two_outputs_different_scan_keys() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk_a = pk(&secp, 2); + let scan_pk_b = pk(&secp, 4); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![ + sp_output(&scan_pk_a, &spend_pk), + sp_output(&scan_pk_b, &spend_pk), + ], + vec![outpoint(0)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + assert_eq!( + psbt.global.sp_ecdh_shares.len(), + 2, + "one share per scan key" + ); + + let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); + assert_eq!(scripts.len(), 2, "one script per SP output"); +} + +// ── 3. Multi-signer eligible-input filtering ────────────────────────────────── + +/// `multi_signer_generate_ecdh_shares` must only produce shares for SP-eligible inputs +/// and silently skip non-eligible ones. +/// +/// Before the `eligible_vins` fix, the subsequent `compute_sp_outputs` call would panic +/// because it iterated over every vin including non-eligible ones and failed to find a +/// share for them. +#[test] +fn test_multi_signer_share_generation_skips_non_eligible_input() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + + // Input 0: eligible P2WPKH owned by spend_sk. + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + // Input 1: non-eligible empty-script input (BIP-352 excludes it from ECDH). + let mut nonelig = Input::new(&outpoint(1)); + nonelig.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut nonelig, + TxOut { + value: Amount::from_sat(5_000), + script_pubkey: ScriptBuf::default(), // empty → not eligible + }, + ); + psbt.inputs[1] = nonelig; + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Partial) + .unwrap(); + + assert!( + !psbt.inputs[0].sp_ecdh_shares.is_empty(), + "eligible input must have a share" + ); + assert!( + psbt.inputs[1].sp_ecdh_shares.is_empty(), + "non-eligible input must not receive a share" + ); +} + +/// `single_signer_generate_ecdh_shares` followed by `compute_sp_outputs` must work +/// correctly even when one of the inputs is not BIP-352 eligible. +/// +/// The global share is computed over the eligible input keys only; the non-eligible +/// input is pushed into `TransactionInputs` with `pubkey = None` and skipped when +/// computing the eligible pubkeys sum and input hash. +#[test] +fn test_single_signer_ignores_non_eligible_input() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + let mut nonelig = Input::new(&outpoint(1)); + nonelig.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut nonelig, + TxOut { + value: Amount::from_sat(3_000), + script_pubkey: ScriptBuf::default(), + }, + ); + psbt.inputs[1] = nonelig; + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); + assert_eq!(scripts.len(), 1); + psbt.commit_sp_outputs(&secp).unwrap(); + + let sp_out = psbt + .outputs + .iter() + .find(|o| o.sp_v0_info.is_some()) + .unwrap(); + assert!(sp_out.script_pubkey.is_p2tr()); +} + +// ── 4. extract_eligible_input_pubkey unit tests ─────────────────────────────── + +/// P2WPKH input with `bip32_derivations` populated → returns the correct pubkey. +#[test] +fn test_extract_p2wpkh_with_derivation_returns_pubkey() { + let secp = secp(); + let secret = sk(1); + let public = secret.public_key(&secp); + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(1_000), + script_pubkey: p2wpkh_script(&secp, &secret), + }, + ); + input.bip32_derivations.insert( + bitcoin::PublicKey::new(public), + (Fingerprint::default(), DerivationPath::default()), + ); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert_eq!(result, Some(public)); +} + +/// P2WPKH input without `bip32_derivations` → returns `Ok(None)`: the pubkey cannot +/// be named, so lenient callers skip the input and strict ones (ShareMode::Global, +/// output derivation) turn the `None` into an error themselves. +#[test] +fn test_extract_p2wpkh_missing_derivation_returns_none() { + let secp = secp(); + let secret = sk(1); + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(1_000), + script_pubkey: p2wpkh_script(&secp, &secret), + }, + ); + // Deliberately omit bip32_derivations. + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert!( + result.is_none(), + "must return None when bip32_derivations is absent for a P2WPKH input" + ); +} + +/// A P2TR output that really is NUMS_H tweaked by `tap_merkle_root` must return `Ok(None)`. +/// +/// BIP-352 §3 excludes script-path-only outputs. The claim is accepted only when the +/// merkle root reproduces the funding scriptPubKey. +#[test] +fn test_extract_p2tr_nums_h_internal_key_returns_none() { + let secp = secp(); + let nums = XOnlyPublicKey::from_slice(&NUMS_H).unwrap(); + let merkle_root = bitcoin::TapNodeHash::from_byte_array([1u8; 32]); + let mut input = Input::new(&outpoint(0)); + input.witness_utxo = Some(TxOut { + value: Amount::from_sat(1_000), + script_pubkey: ScriptBuf::new_p2tr(&secp, nums, Some(merkle_root)), + }); + input.tap_internal_key = Some(nums); + input.tap_merkle_root = Some(merkle_root); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert!( + result.is_none(), + "a NUMS_H script-path output must be non-contributing" + ); +} + +/// An input whose `witness_utxo` has a non-eligible scriptPubKey must return `Ok(None)`. +#[test] +fn test_extract_non_eligible_script_returns_none() { + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(0), + script_pubkey: ScriptBuf::default(), // empty → not eligible + }, + ); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert!(result.is_none()); +} + +/// P2SH input where the redeem script is NOT P2WPKH → must return `Ok(None)`. +#[test] +fn test_extract_p2sh_non_wpkh_redeem_returns_none() { + let secp = secp(); + let secret = sk(1); + // Redeem script: a P2TR (not a P2WPKH). Any non-P2WPKH redeem is excluded. + let non_wpkh_redeem = p2tr_script(&secp, &secret); + let p2sh_script = ScriptBuf::new_p2sh(&non_wpkh_redeem.script_hash()); + + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(1_000), + script_pubkey: p2sh_script, + }, + ); + input.redeem_script = Some(non_wpkh_redeem); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert!( + result.is_none(), + "P2SH with non-P2WPKH redeem must be ineligible" + ); +} + +/// P2SH input with no redeem script set → must return `Ok(None)` (field not +/// populated yet). +#[test] +fn test_extract_p2sh_missing_redeem_script_returns_none() { + let secp = secp(); + let secret = sk(1); + let p2wpkh = p2wpkh_script(&secp, &secret); + let p2sh_script = ScriptBuf::new_p2sh(&p2wpkh.script_hash()); + + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(1_000), + script_pubkey: p2sh_script, + }, + ); + // redeem_script intentionally absent. + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert!(result.is_none()); +} + +#[test] +fn test_multi_signer_compute_sp_outputs_with_non_eligible_input() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + let mut nonelig = Input::new(&outpoint(1)); + nonelig.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut nonelig, + TxOut { + value: Amount::from_sat(5_000), + script_pubkey: ScriptBuf::default(), + }, + ); + psbt.inputs[1] = nonelig; + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Partial) + .unwrap(); + + // The non-eligible input requires no share; derivation must succeed from the + // eligible input's partial share alone. + psbt.derive_sp_output_scripts(&secp).unwrap(); +} + +/// P2TR input with `sp_tweak` set (SP spend): the BIP-352 input pubkey is the +/// even-lifted output key from the funding scriptPubKey — for an SP output that +/// is `B_spend + tweak·G` by construction. Per BIP-376 the +/// `sp_spend_bip32_derivations` map key is the *untweaked* spend key and is only +/// used for signer key lookup; it must not be read here. +#[test] +fn test_extract_p2tr_sp_tweak_reads_output_key_from_prevout() { + let secp = secp(); + let spend = sk(1); + let tweak = Scalar::from_be_bytes(sk(2).secret_bytes()).unwrap(); + let tweaked = spend.add_tweak(&tweak).unwrap(); + let (xonly, _) = tweaked.x_only_public_key(&secp); + + let mut input = Input::new(&outpoint(0)); + input.witness_utxo = Some(TxOut { + value: Amount::from_sat(1_000), + // SP outputs place the derived key directly, without a BIP-341 tweak. + script_pubkey: ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()), + }); + input.sp_tweak = Some(sk(2).secret_bytes()); + // BIP-376: the map key is the untweaked spend key B_spend. + input.sp_spend_bip32_derivations.insert( + CompressedPublicKey(spend.public_key(&secp)), + (Fingerprint::default(), DerivationPath::default()), + ); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert_eq!(result, Some(xonly.public_key(Parity::Even))); +} + +/// An SP input without `sp_spend_bip32_derivations` still yields its output key: +/// the field is a key-lookup aid (BIP-376 SHOULD), not an input to the ECDH +/// extraction. Its presence is enforced by validation, not by this function. +#[test] +fn test_extract_p2tr_sp_tweak_without_derivation_map() { + let secp = secp(); + let tweaked = sk(1) + .add_tweak(&Scalar::from_be_bytes(sk(2).secret_bytes()).unwrap()) + .unwrap(); + let (xonly, _) = tweaked.x_only_public_key(&secp); + + let mut input = Input::new(&outpoint(0)); + input.witness_utxo = Some(TxOut { + value: Amount::from_sat(1_000), + script_pubkey: ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()), + }); + input.sp_tweak = Some(sk(2).secret_bytes()); + + let result = extract_eligible_input_pubkey(&input).unwrap(); + assert_eq!(result, Some(xonly.public_key(Parity::Even))); +} + +// ── 6. sign_sp_inputs ───────────────────────────────────────────────────────── + +/// Signing an SP input must produce a Schnorr signature that verifies against the +/// output key from the funding scriptPubKey, over the key-spend sighash of the +/// unsigned transaction. +/// +/// BIP-375 forbids adding signatures while any silent-payment output still has an +/// empty scriptPubKey, so this test uses a plain (non-SP) output. +#[test] +fn test_sign_sp_inputs_produces_valid_taproot_sig() { + let secp = secp(); + let spend_sk = sk(1); + let tweak_bytes = sk(7).secret_bytes(); + + let payment_output = Output::new(TxOut { + value: Amount::from_sat(10_000), + script_pubkey: p2wpkh_script(&secp, &sk(9)), + }); + let mut psbt = new_psbt(vec![payment_output], vec![outpoint(0)]); + psbt.inputs[0] = sp_p2tr_input(&secp, outpoint(0), &spend_sk, tweak_bytes); + + let psbt = sign_sp_input(psbt, &spend_sk, &secp); + + let tweaked = spend_sk + .add_tweak(&Scalar::from_be_bytes(tweak_bytes).unwrap()) + .unwrap(); + let (output_key, _) = tweaked.x_only_public_key(&secp); + + let sig = psbt.inputs[0] + .tap_key_sig + .expect("tap_key_sig must be set after signing"); + + // Verify the signature against the sighash of the unsigned transaction. + // (`Psbt::unsigned_tx` is private upstream; rebuild it from the PSBT fields.) + let tx = bitcoin::Transaction { + version: psbt.global.tx_version, + lock_time: psbt + .global + .fallback_lock_time + .unwrap_or(bitcoin::absolute::LockTime::ZERO), + input: psbt + .inputs + .iter() + .map(|i| bitcoin::TxIn { + previous_output: OutPoint::new(i.previous_txid, i.spent_output_index), + script_sig: ScriptBuf::new(), + sequence: i.sequence.unwrap_or(Sequence::MAX), + witness: bitcoin::Witness::new(), + }) + .collect(), + output: psbt + .outputs + .iter() + .map(|o| TxOut { + value: o.amount, + script_pubkey: o.script_pubkey.clone(), + }) + .collect(), + }; + let prevouts = [psbt.inputs[0].witness_utxo.clone().unwrap()]; + let sighash = SighashCache::new(&tx) + .taproot_key_spend_signature_hash(0, &Prevouts::All(&prevouts), sig.sighash_type) + .unwrap(); + secp.verify_schnorr(&sig.signature, &Message::from(sighash), &output_key) + .unwrap(); +} + +// ── 7. Receiver-verified end-to-end ────────────────────────────────────────── + +/// Full single-signer flow spending *from* an SP input (P2TR with `sp_tweak`): +/// share generation must resolve the tweaked key, and the recipient must be able +/// to scan the derived output. Exercises the taproot branch of +/// `resolve_owned_eligible_key` / `NormalizedSecretKey` that P2WPKH-only tests miss. +#[test] +fn test_single_signer_sp_input_receiver_can_scan() { + let secp = secp(); + let input_spend_sk = sk(1); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + let tweak_bytes = sk(7).secret_bytes(); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = sp_p2tr_input(&secp, outpoint(0), &input_spend_sk, tweak_bytes); + + psbt.add_ecdh_shares(&secp, &mut rng(), &input_spend_sk, ShareMode::Global) + .unwrap(); + let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); + assert_eq!(scripts.len(), 1); + psbt.commit_sp_outputs(&secp).unwrap(); + + assert_receiver_scan_finds_outputs(&secp, &psbt, &scan_sk, &spend_pk); +} + +/// An SP input has no `tap_internal_key` (BIP-352 outputs have no internal +/// key), so the finalizer must build the key-path witness from `tap_key_sig` +/// alone. Regression test: rust-psbt's `construct_tap_witness` used to gate +/// the key-spend path on `tap_internal_key`, making every SP spend +/// unfinalizable ("failed to finalize input at index N") even though the +/// signature was present and valid. +#[test] +fn test_sp_input_finalizes_without_tap_internal_key() { + let secp = secp(); + let spend_sk = sk(1); + let tweak_bytes = sk(7).secret_bytes(); + + let payment_output = Output::new(TxOut { + value: Amount::from_sat(10_000), + script_pubkey: p2wpkh_script(&secp, &sk(9)), + }); + let mut psbt = new_psbt(vec![payment_output], vec![outpoint(0)]); + psbt.inputs[0] = sp_p2tr_input(&secp, outpoint(0), &spend_sk, tweak_bytes); + assert!( + psbt.inputs[0].tap_internal_key.is_none(), + "SP inputs must not carry an internal key" + ); + + let psbt = sign_sp_input(psbt, &spend_sk, &secp); + let sig = psbt.inputs[0].tap_key_sig.expect("tap_key_sig set"); + + let finalized = Finalizer::new(psbt) + .expect("finalizer") + .finalize(&secp) + .expect("SP input must finalize"); + let witness = finalized.inputs[0] + .final_script_witness + .as_ref() + .expect("final witness set"); + assert_eq!(witness.to_vec(), vec![sig.to_vec()]); + + let tx = Extractor::new(finalized) + .expect("Transaction finalized") + .extract_tx() + .expect("extract tx"); + assert_eq!(tx.input[0].witness.to_vec(), vec![sig.to_vec()]); +} + +/// True two-party flow: each signer contributes per-input shares for their own +/// input only, the PSBTs are merged (manually — no Combiner role exists yet), and +/// the recipient can scan the resulting SP output. +#[test] +fn test_multi_signer_two_parties_receiver_can_scan() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + let bob_tweak = sk(8).secret_bytes(); + + let base = { + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + // Alice: plain P2WPKH input. Bob: SP P2TR input (taproot share path). + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &alice_sk); + psbt.inputs[1] = sp_p2tr_input(&secp, outpoint(1), &bob_sk, bob_tweak); + psbt + }; + + let mut psbt_alice = base.clone(); + psbt_alice + .add_ecdh_shares(&secp, &mut rng(), &alice_sk, ShareMode::Partial) + .unwrap(); + let mut psbt_bob = base; + psbt_bob + .add_ecdh_shares(&secp, &mut rng(), &bob_sk, ShareMode::Partial) + .unwrap(); + + // Each signer must contribute to their own input only. + assert!(!psbt_alice.inputs[0].sp_ecdh_shares.is_empty()); + assert!(psbt_alice.inputs[1].sp_ecdh_shares.is_empty()); + assert!(psbt_bob.inputs[0].sp_ecdh_shares.is_empty()); + assert!(!psbt_bob.inputs[1].sp_ecdh_shares.is_empty()); + + // No Combiner role exists yet: merge the per-input fields manually. + psbt_alice.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); + psbt_alice.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); + + psbt_alice.commit_sp_outputs(&secp).unwrap(); + + assert_receiver_scan_finds_outputs(&secp, &psbt_alice, &scan_sk, &spend_pk); +} + +/// BIP-375 "Computing the Output Scripts": when a scan key has both a global +/// share and per-input shares, the global share takes precedence and the +/// partials are ignored — even a per-input share that could never verify on its +/// own (here: no DLEQ proof at all). `add_ecdh_shares` never produces the mix, +/// so build it by hand, as a combiner merging redundant fields would. +#[test] +fn test_mixed_share_state_global_precedence() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + let expected = psbt.derive_sp_output_scripts(&secp).unwrap(); + + // Simulate a combiner merging in a redundant (and proof-less) per-input share. + let (&scan_key, &share) = psbt.global.sp_ecdh_shares.iter().next().unwrap(); + psbt.inputs[0].sp_ecdh_shares.insert(scan_key, share); + + assert_eq!( + psbt.derive_sp_output_scripts(&secp).unwrap(), + expected, + "per-input shares must be ignored when a global share exists" + ); +} + +/// When a global share fails verification but every eligible input carries a +/// valid partial share, derivation falls back to the partials. Verified partial +/// proofs bind each share to its input's key, so the fallback necessarily +/// recovers the same secret an honest global share would have produced. +#[test] +fn test_invalid_global_share_falls_back_to_partials() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let base = { + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + psbt + }; + + // Reference: partials only. + let mut psbt_partial = base.clone(); + psbt_partial + .add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Partial) + .unwrap(); + let expected = psbt_partial.derive_sp_output_scripts(&secp).unwrap(); + + // Mixed: valid partials + a global share whose proof is corrupted. + let mut psbt_mixed = base; + psbt_mixed + .add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt_mixed.inputs[0].sp_ecdh_shares = psbt_partial.inputs[0].sp_ecdh_shares.clone(); + psbt_mixed.inputs[0].sp_dleq_proofs = psbt_partial.inputs[0].sp_dleq_proofs.clone(); + for proof in psbt_mixed.global.sp_dleq_proofs.values_mut() { + proof.0[0] ^= 1; + } + + assert_eq!( + psbt_mixed.derive_sp_output_scripts(&secp).unwrap(), + expected, + "fallback to verified partials must recover the same scripts" + ); +} diff --git a/spdk-wallet/Cargo.toml b/spdk-wallet/Cargo.toml index b68d3267..89b01d2d 100644 --- a/spdk-wallet/Cargo.toml +++ b/spdk-wallet/Cargo.toml @@ -12,6 +12,7 @@ crate-type = ["lib", "staticlib", "cdylib"] spdk-core.workspace = true backend-blindbit-v1 = { workspace = true, optional = true } local-scanner = { workspace = true, optional = true, features = ["rayon"] } +psbt.workspace = true anyhow.workspace = true bitcoin.workspace = true diff --git a/spdk-wallet/src/lib.rs b/spdk-wallet/src/lib.rs index 0a938b21..71cb0f67 100644 --- a/spdk-wallet/src/lib.rs +++ b/spdk-wallet/src/lib.rs @@ -1,7 +1,6 @@ mod bip321_parsing; pub mod client; -// re-export traits for consumers who need to provide valid implementors // re-export blindbit backend if enabled #[cfg(feature = "backend-blindbit-v1")] pub use backend_blindbit_v1; @@ -12,5 +11,6 @@ pub use bitcoin; // re-export local scanner if enabled #[cfg(feature = "local-scanner")] pub use local_scanner::SpScanner; +pub use psbt; pub use silentpayments; pub use spdk_core::{chain, scanner}; From 16210d891062ff12aee411450e8e2a2dd8ec7cfc Mon Sep 17 00:00:00 2001 From: Sosthene Date: Tue, 8 Sep 2026 23:12:14 +0200 Subject: [PATCH 07/13] docs: record DLEQ backend decision (standalone over native) Note in the workspace Cargo.toml why we default to rust-dleq's pure-Rust standalone backend, its BIP-374 vector verification status, why the native vendored-libsecp path is deferred, and the triggers to revisit it. --- Cargo.toml | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 9ffe7568..6505b5eb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,6 +39,19 @@ reqwest = { version = "0.12.4", features = [ "gzip", ], default-features = false } psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "2b68fa71ce9638257d38938f4ceba1218238bc47", features = ["silent-payments", "miniscript"] } +# DLEQ (BIP-374) backend decision (2026-09): +# We use rust-dleq's pure-Rust `standalone` backend (the default in `silentpayments` +# and `psbt`), pinned to this fork. It is verified against the official BIP-374 +# test vectors (byte-identical proofs; all negative cases reject). +# +# The `dleq-native` path (vendored libsecp256k1) is deferred: it builds its own +# libsecp256k1.a alongside secp256k1-sys's, and unifying them would mean forking +# rust-secp256k1 and hand-porting its context/memory patches onto the moving +# libsecp PR #1802 branch — not worth it for a stopgap. +# +# Revisit when secp256k1 PR #1802 (or #1651) merges and rust-secp256k1 ships the +# DLEQ module. Also watch bips#2262 (challenge `e` as scalar) — if it lands, both +# the C and standalone impls plus the test vectors change. rust-dleq = { git = "https://github.com/Sosthene00/rust-dleq.git", rev = "097644a14d87c454e9bd9895de2e60992ff1ba93", default-features = false } secp256k1 = { version = "0.29.0" } From 5ac9b06861bec288094d256f498124e1f4573bd0 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Thu, 1 Oct 2026 19:30:20 +0200 Subject: [PATCH 08/13] feat(spdk-wallet): construct spends as BIP-375 PSBTs The hand-rolled unsigned transaction cannot carry DLEQ ECDH shares or hand signing off to the psbt crate. Freeze the selected inputs and outputs on a PSBT and derive scripts only at finalize time. --- Cargo.toml | 2 +- README.md | 6 +- psbt/src/extractor.rs | 151 +++++++ psbt/src/lib.rs | 14 +- psbt/src/roles/mod.rs | 16 - psbt/src/{roles => }/signer.rs | 265 ++++++------ psbt/tests/bip375_vectors.rs | 67 ++- psbt/tests/signer.rs | 18 +- spdk-wallet/Cargo.toml | 1 + spdk-wallet/src/client/coin_select.rs | 6 +- spdk-wallet/src/client/spend.rs | 565 +++++++++++--------------- spdk-wallet/src/client/structs.rs | 27 +- spdk-wallet/src/lib.rs | 4 +- 13 files changed, 640 insertions(+), 502 deletions(-) create mode 100644 psbt/src/extractor.rs delete mode 100644 psbt/src/roles/mod.rs rename psbt/src/{roles => }/signer.rs (83%) diff --git a/Cargo.toml b/Cargo.toml index 6505b5eb..bf67be63 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,7 +38,7 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } -psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "2b68fa71ce9638257d38938f4ceba1218238bc47", features = ["silent-payments", "miniscript"] } +psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "fceb052fa0a4a35f6ddda823d5b9c17f945a9078", features = ["silent-payments", "miniscript"] } # DLEQ (BIP-374) backend decision (2026-09): # We use rust-dleq's pure-Rust `standalone` backend (the default in `silentpayments` # and `psbt`), pinned to this fork. It is verified against the official BIP-374 diff --git a/README.md b/README.md index 9dae4bd5..1f3264b0 100644 --- a/README.md +++ b/README.md @@ -3,14 +3,16 @@ > [!WARNING] > SPDK currently relies on cryptography that is not professionally reviewed. Be mindful of this when using SPDK with real funds. -SPDK is a library that can be used to build silent payment-based wallets. It consists of 4 sub-crates: +SPDK is a library that can be used to build silent payment-based wallets. It consists of these sub-crates: - **spdk-core**, an internal library that is used for organizing crates within this workspace. - Defines a `ChainBackend` trait, that can be used be consumers (e.g. backend-blindbit-v1) to provide chain data. - Defines an `Updater` trait, that can be used by wallets to receive updates while scanning the chain. - **backend-blindbit-v1**, a chain backend that implements a [bip352 light client](https://github.com/setavenger/BIP0352-light-client-specification). +- **local-scanner**, an implementation of the `Scanner` trait that scans through a `ChainBackend`. - **silentpayments**, the cryptography library that implements silent-payment related operations. Note: although this library passes the test vectors from the BIP, it is not professionally reviewed for security. -- **spdk-wallet**, a high-level crate that implements a `Client` and a `Scanner`. These can be used to scan the chain for incoming payments, and creating and signing transactions. +- **psbt**, BIP-375 extensions (`signer`, `extractor`) for the `psbt-v2` crate. `Psbt` and the upstream PSBT roles are in `psbt-v2`. +- **spdk-wallet**, a high-level crate that implements a `Client` and a `Scanner`. These can be used to scan the chain for incoming payments, and creating and signing transactions. It reexports `signer`, `extractor`, and `psbt-v2`. ## How to use diff --git a/psbt/src/extractor.rs b/psbt/src/extractor.rs new file mode 100644 index 00000000..e8f93b33 --- /dev/null +++ b/psbt/src/extractor.rs @@ -0,0 +1,151 @@ +//! BIP-375 Transaction Extractor. +//! +//! BIP-375: "For silent payment capable PSBTs, the transaction extractor should compute all +//! output scripts for silent payment codes and verify they are correct using the ECDH shares and +//! DLEQ proofs, otherwise fail." +//! +//! `psbt_v2::Extractor` leaves that check to the caller, because it needs BIP-352 output +//! derivation and BIP-374 proof verification. This role performs it before extracting. + +use std::fmt; + +use bitcoin::Transaction; +use psbt_v2::{ExtractError, ExtractTxFeeRateError, Extractor, Psbt}; +use secp256k1::{Secp256k1, Signing, Verification}; +use silentpayments::TransactionInputs; +use silentpayments::utils::OutPoint as SpOutPoint; +use silentpayments::utils::receiving::get_pubkey_from_input; + +use super::signer::{SpSignerError, derive_sp_output_scripts_from_inputs, funding_output}; + +#[derive(Debug)] +pub enum SpExtractorError { + /// The public key of a finalized input could not be recovered from its scriptSig and + /// witness. + InputPubkey { + vin: usize, + error: silentpayments::Error, + }, + /// The silent payment output scripts could not be derived from the ECDH shares. + Derive(SpSignerError), + /// A silent payment output does not match the script derived from the ECDH shares. + OutputScriptMismatch { index: usize }, + /// rust-psbt refused to build an extractor for the PSBT. + Extractor(ExtractError), + /// rust-psbt failed to extract the transaction. + ExtractTx(ExtractTxFeeRateError), +} + +impl fmt::Display for SpExtractorError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use SpExtractorError as E; + match self { + E::InputPubkey { vin, error } => { + write!(f, "input {vin}: cannot recover its public key: {error}") + } + E::Derive(e) => write!(f, "cannot derive silent payment output scripts: {e}"), + E::OutputScriptMismatch { index } => write!( + f, + "silent payment output {index} does not match the script derived from the ECDH shares" + ), + E::Extractor(e) => write!(f, "cannot extract: {e}"), + E::ExtractTx(e) => write!(f, "cannot extract the transaction: {e}"), + } + } +} + +impl std::error::Error for SpExtractorError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + use SpExtractorError as E; + match self { + E::InputPubkey { error, .. } => Some(error), + E::Derive(e) => Some(e), + E::Extractor(e) => Some(e), + E::ExtractTx(e) => Some(e), + E::OutputScriptMismatch { .. } => None, + } + } +} + +impl From for SpExtractorError { + fn from(value: SpSignerError) -> Self { + Self::Derive(value) + } +} + +pub trait SpExtractorExt { + /// Derives every silent payment output script from the ECDH shares and DLEQ proofs and + /// checks it against the PSBT, as BIP-375 requires of the Transaction Extractor. + /// + /// The Input Finalizer clears the fields the Signer reads input public keys from, so they + /// are recovered from the final scriptSig and witness, as a BIP-352 receiver does. + fn verify_sp_output_scripts(&self, secp: &Secp256k1) -> Result<(), SpExtractorError> + where + C: Signing + Verification; + + /// Verifies the silent payment output scripts, then extracts the transaction with + /// `psbt_v2::Extractor`. + fn extract_tx(self, secp: &Secp256k1) -> Result + where + C: Signing + Verification; +} + +impl SpExtractorExt for Psbt { + fn verify_sp_output_scripts(&self, secp: &Secp256k1) -> Result<(), SpExtractorError> + where + C: Signing + Verification, + { + if self + .outputs + .iter() + .all(|output| output.sp_v0_info.is_none()) + { + return Ok(()); + } + + let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count); + for (vin, input) in self.inputs.iter().enumerate() { + let outpoint = SpOutPoint::from_txid_and_vout( + &input.previous_txid.to_string(), + input.spent_output_index, + ) + .map_err(SpSignerError::from)?; + let spk = &funding_output(input) + .map_err(SpSignerError::from)? + .script_pubkey; + let script_sig = input + .final_script_sig + .as_ref() + .map(|script| script.as_bytes()) + .unwrap_or_default(); + let witness = input + .final_script_witness + .as_ref() + .map(|witness| witness.to_vec()) + .unwrap_or_default(); + let pubkey = get_pubkey_from_input(script_sig, &witness, spk.as_bytes()) + .map_err(|error| SpExtractorError::InputPubkey { vin, error })?; + transaction_inputs.push(outpoint, spk.to_bytes(), pubkey); + } + + for (index, script) in + derive_sp_output_scripts_from_inputs(self, secp, &transaction_inputs)? + { + if self.outputs[index].script_pubkey != script { + return Err(SpExtractorError::OutputScriptMismatch { index }); + } + } + Ok(()) + } + + fn extract_tx(self, secp: &Secp256k1) -> Result + where + C: Signing + Verification, + { + self.verify_sp_output_scripts(secp)?; + Extractor::new(self) + .map_err(SpExtractorError::Extractor)? + .extract_tx() + .map_err(SpExtractorError::ExtractTx) + } +} diff --git a/psbt/src/lib.rs b/psbt/src/lib.rs index 89bf6f0a..49fa86c7 100644 --- a/psbt/src/lib.rs +++ b/psbt/src/lib.rs @@ -1,6 +1,12 @@ -//! BIP-375 PSBT Module +//! BIP-375 extensions for `psbt-v2` PSBTs. //! -//! This module contains the BIP-375 PSBT functionality: -//! - `roles`: PSBT role implementations (signer, finalizer, extractor) +//! - [`signer`]: ECDH shares and silent-payment output derivation. +//! - [`extractor`]: output-script check before extraction. +//! +//! `Psbt` and the upstream signer, finalizer, and extractor types are in `psbt-v2`. +//! +//! A combiner for concurrent signers is not implemented. It would merge ECDH shares, DLEQ +//! proofs, and signatures, and reject conflicting values for the same field. -pub mod roles; +pub mod extractor; +pub mod signer; diff --git a/psbt/src/roles/mod.rs b/psbt/src/roles/mod.rs deleted file mode 100644 index b62389ce..00000000 --- a/psbt/src/roles/mod.rs +++ /dev/null @@ -1,16 +0,0 @@ -//! BIP-375 PSBT Roles -//! -//! Implements the PSBT roles defined in BIP-174/370/375: -//! - Signer -//! -//! ## TODO: Future Enhancements -//! -//! - **Combiner role**: For async multi-party signing workflows -//! - Current examples use sequential signing (hardware-signer, multi-signer) -//! - Future enhancement: Merge PSBTs from concurrent signers -//! - Would handle union of ECDH shares, DLEQ proofs, and signatures -//! - Conflict detection for same-field different-value scenarios - -pub mod signer; - -pub use signer::*; diff --git a/psbt/src/roles/signer.rs b/psbt/src/signer.rs similarity index 83% rename from psbt/src/roles/signer.rs rename to psbt/src/signer.rs index 519ca151..786e1436 100644 --- a/psbt/src/roles/signer.rs +++ b/psbt/src/signer.rs @@ -1,6 +1,6 @@ //! PSBT Signer Role //! -//! This module extends the upstream [`psbt_v2::Signer`] with the two pieces of +//! This module extends the upstream `psbt_v2::Signer` with the two pieces of //! the BIP-375 signer role it does not implement: //! //! - **ECDH share generation** ([`SpSignerExt::add_ecdh_shares`]): global shares for a single @@ -59,9 +59,9 @@ pub enum SpSignerError { /// Structurally malformed input (e.g. `sp_tweak` set on a non-P2TR input). MalformedInput { vin: usize, detail: &'static str }, /// [`ShareMode::Global`]: an eligible input's key could not be resolved from the - /// provided [`GetKey`], so the global share cannot cover every input. + /// provided `psbt_v2::GetKey`, so the global share cannot cover every input. KeyResolution { vin: usize }, - /// The [`GetKey`] backend errored during a lookup. + /// The `psbt_v2::GetKey` backend errored during a lookup. GetKey { vin: usize, error: String }, /// [`ShareMode::Partial`]: none of the inputs are owned by the provided keys. NoOwnedInputs, @@ -374,23 +374,14 @@ impl SpSignerExt for Psbt { where C: Signing + Verification, { - // Recipient key material per SP output. `generate_recipient_pubkeys` assigns - // the BIP-352 n-counter within each scan-key group in the order entries are - // given, and the reference vectors expect that order to be the outputs sorted - // by `sp_v0_info` (ties broken by output index) — not raw output order. This - // matters when one scan key is paid with different labels. - let sp_outputs = collect_sp_v0_keys(self); - if sp_outputs.is_empty() { + if self + .outputs + .iter() + .all(|output| output.sp_v0_info.is_none()) + { return Ok(Vec::new()); } - let sorted_materials: Vec = sp_outputs - .iter() - .map(|(_, sp_info)| sp_info_to_key_material(sp_info)) - .collect(); - - let scan_keys = collect_scan_keys(&sp_outputs); - // The BIP-352 input set, exactly as the receiver rebuilds it. let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count); for (vin, input) in self.inputs.iter().enumerate() { @@ -405,106 +396,8 @@ impl SpSignerExt for Psbt { } transaction_inputs.push(outpoint, spk, pubkey); } - let eligible_vins = transaction_inputs.eligible_vins(); - - // Aggregate of every eligible input's partial share for one scan key. - // Primary source when no global share exists, fallback when the global - // share fails verification (see below). - let partials_secret = - |ck: CompressedPublicKey| -> Result { - // Every eligible input must provide a partial share with its proof. - let mut partials = Vec::with_capacity(eligible_vins.len()); - for &vin in &eligible_vins { - let input = &self.inputs[vin]; - let share = input - .sp_ecdh_shares - .get(&ck) - .ok_or(SpSignerError::MissingShare { scan_key: ck, vin })?; - let proof = - input - .sp_dleq_proofs - .get(&ck) - .ok_or(SpSignerError::MissingDleqProof { - scan_key: ck, - vin: Some(vin), - })?; - partials.push(PartialSenderEcdhShare::new_unchecked( - ck.0, - vin, - share.0, - to_rust_dleq(*proof), - )); - } - Ok(TransactionSharedSecret::new_from_partial_shares( - secp, - ck.0, - NonEmptyArray::new(&partials)?, - &transaction_inputs, - )?) - }; - - // One transaction shared secret per scan key. DLEQ proofs are verified - // inside the `TransactionSharedSecret` constructors. - let mut shared_secrets: HashMap = - HashMap::with_capacity(scan_keys.len()); - for ck in scan_keys { - // A global share takes precedence (BIP-375 "Computing the Output - // Scripts": use PSBT_GLOBAL_SP_ECDH_SHARE "if available"). Combiners - // can legitimately produce PSBTs that also carry per-input shares for - // the same scan key — the official vectors treat that state as valid - // — so coexisting partials never replace a *verifiable* global share. - // We never *produce* the overlap ourselves: `add_ecdh_shares` rejects - // it. - // - // Fallback: when the global share fails verification, complete partial - // coverage is tried before giving up. This is sound because a verified - // partial DLEQ proof binds its share to the input's prevout pubkey, - // so fully verified partials determine the one correct secret — the - // fallback can only recover that value or fail, never commit to a - // wrong one. If the fallback fails too, the original global error is - // reported. A *missing* global proof does not fall back: BIP-375 - // lists it as an invalid state. - let scan_key = ck.0; - let shared_secret = if let Some(share) = self.global.sp_ecdh_shares.get(&ck) { - let proof = - self.global - .sp_dleq_proofs - .get(&ck) - .ok_or(SpSignerError::MissingDleqProof { - scan_key: ck, - vin: None, - })?; - let global = - GlobalSenderEcdhShare::new_unchecked(scan_key, share.0, to_rust_dleq(*proof)); - TransactionSharedSecret::new_from_global_share(secp, &global, &transaction_inputs) - .or_else(|global_err| partials_secret(ck).map_err(|_| global_err))? - } else { - partials_secret(ck)? - }; - shared_secrets.insert(scan_key, shared_secret); - } - let mut derived = generate_recipient_pubkeys(secp, sorted_materials, &shared_secrets)?; - - // Assign back in output-index order: within one key material the sorted - // order coincides with index order, so popping per material is exact. - let mut scripts = Vec::with_capacity(sp_outputs.len()); - for (index, sp_info) in sp_outputs { - let key_material = sp_info_to_key_material(&sp_info); - let keys = derived - .get_mut(&key_material) - .expect("every submitted recipient is derived"); - let xonly = keys - .first() - .copied() - .expect("one derived key per submitted recipient"); - keys.remove(0); - scripts.push(( - index, - ScriptBuf::new_p2tr_tweaked(TweakedPublicKey::dangerous_assume_tweaked(xonly)), - )); - } - Ok(scripts) + derive_sp_output_scripts_from_inputs(self, secp, &transaction_inputs) } fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> @@ -522,6 +415,138 @@ impl SpSignerExt for Psbt { } } +/// Derives the silent payment output scripts from the PSBT's ECDH shares. +/// +/// Verifies each share's DLEQ proof against the input public keys in `transaction_inputs`, so +/// the caller decides where those keys come from: the Updater's fields while signing, or the +/// final scriptSig and witness once the inputs are finalized. +pub(crate) fn derive_sp_output_scripts_from_inputs( + psbt: &Psbt, + secp: &Secp256k1, + transaction_inputs: &TransactionInputs, +) -> Result, SpSignerError> +where + C: Signing + Verification, +{ + // Recipient key material per SP output. `generate_recipient_pubkeys` assigns + // the BIP-352 n-counter within each scan-key group in the order entries are + // given, and the reference vectors expect that order to be the outputs sorted + // by `sp_v0_info` (ties broken by output index) — not raw output order. This + // matters when one scan key is paid with different labels. + let sp_outputs = collect_sp_v0_keys(psbt); + if sp_outputs.is_empty() { + return Ok(Vec::new()); + } + + let sorted_materials: Vec = sp_outputs + .iter() + .map(|(_, sp_info)| sp_info_to_key_material(sp_info)) + .collect(); + + let scan_keys = collect_scan_keys(&sp_outputs); + + let eligible_vins = transaction_inputs.eligible_vins(); + + // Aggregate of every eligible input's partial share for one scan key. + // Primary source when no global share exists, fallback when the global + // share fails verification (see below). + let partials_secret = + |ck: CompressedPublicKey| -> Result { + // Every eligible input must provide a partial share with its proof. + let mut partials = Vec::with_capacity(eligible_vins.len()); + for &vin in &eligible_vins { + let input = &psbt.inputs[vin]; + let share = input + .sp_ecdh_shares + .get(&ck) + .ok_or(SpSignerError::MissingShare { scan_key: ck, vin })?; + let proof = + input + .sp_dleq_proofs + .get(&ck) + .ok_or(SpSignerError::MissingDleqProof { + scan_key: ck, + vin: Some(vin), + })?; + partials.push(PartialSenderEcdhShare::new_unchecked( + ck.0, + vin, + share.0, + to_rust_dleq(*proof), + )); + } + Ok(TransactionSharedSecret::new_from_partial_shares( + secp, + ck.0, + NonEmptyArray::new(&partials)?, + transaction_inputs, + )?) + }; + + // One transaction shared secret per scan key. DLEQ proofs are verified + // inside the `TransactionSharedSecret` constructors. + let mut shared_secrets: HashMap = + HashMap::with_capacity(scan_keys.len()); + for ck in scan_keys { + // A global share takes precedence (BIP-375 "Computing the Output + // Scripts": use PSBT_GLOBAL_SP_ECDH_SHARE "if available"). Combiners + // can legitimately produce PSBTs that also carry per-input shares for + // the same scan key — the official vectors treat that state as valid + // — so coexisting partials never replace a *verifiable* global share. + // We never *produce* the overlap ourselves: `add_ecdh_shares` rejects + // it. + // + // Fallback: when the global share fails verification, complete partial + // coverage is tried before giving up. This is sound because a verified + // partial DLEQ proof binds its share to the input's prevout pubkey, + // so fully verified partials determine the one correct secret — the + // fallback can only recover that value or fail, never commit to a + // wrong one. If the fallback fails too, the original global error is + // reported. A *missing* global proof does not fall back: BIP-375 + // lists it as an invalid state. + let scan_key = ck.0; + let shared_secret = if let Some(share) = psbt.global.sp_ecdh_shares.get(&ck) { + let proof = + psbt.global + .sp_dleq_proofs + .get(&ck) + .ok_or(SpSignerError::MissingDleqProof { + scan_key: ck, + vin: None, + })?; + let global = + GlobalSenderEcdhShare::new_unchecked(scan_key, share.0, to_rust_dleq(*proof)); + TransactionSharedSecret::new_from_global_share(secp, &global, transaction_inputs) + .or_else(|global_err| partials_secret(ck).map_err(|_| global_err))? + } else { + partials_secret(ck)? + }; + shared_secrets.insert(scan_key, shared_secret); + } + + let mut derived = generate_recipient_pubkeys(secp, sorted_materials, &shared_secrets)?; + + // Assign back in output-index order: within one key material the sorted + // order coincides with index order, so popping per material is exact. + let mut scripts = Vec::with_capacity(sp_outputs.len()); + for (index, sp_info) in sp_outputs { + let key_material = sp_info_to_key_material(&sp_info); + let keys = derived + .get_mut(&key_material) + .expect("every submitted recipient is derived"); + let xonly = keys + .first() + .copied() + .expect("one derived key per submitted recipient"); + keys.remove(0); + scripts.push(( + index, + ScriptBuf::new_p2tr_tweaked(TweakedPublicKey::dangerous_assume_tweaked(xonly)), + )); + } + Ok(scripts) +} + /// Distinct scan keys among the SP outputs. It must be called with the output of /// `collect_sp_v0_keys` to guarantee it is sorted. We still sort the keys before deduping to be /// sure. @@ -534,17 +559,19 @@ fn collect_scan_keys(sp_v0_info: &[(usize, SpV0Info)]) -> Vec Result<&bitcoin::TxOut, FundingUtxoError> { +pub(crate) fn funding_output(input: &Input) -> Result<&bitcoin::TxOut, FundingUtxoError> { match input.funding_utxo_untrusted() { Err(FundingUtxoError::UnverifiableUtxo) => input .witness_utxo diff --git a/psbt/tests/bip375_vectors.rs b/psbt/tests/bip375_vectors.rs index 6250e81f..a70d956f 100644 --- a/psbt/tests/bip375_vectors.rs +++ b/psbt/tests/bip375_vectors.rs @@ -7,8 +7,9 @@ use std::fs; use std::path::PathBuf; use bitcoin::base64::prelude::{BASE64_STANDARD, Engine as _}; -use psbt::roles::SpSignerExt; -use psbt_v2::{Psbt, SilentPaymentState}; +use psbt::extractor::{SpExtractorError, SpExtractorExt}; +use psbt::signer::SpSignerExt; +use psbt_v2::{Finalizer, Psbt, SilentPaymentState}; use secp256k1::Secp256k1; use serde::Deserialize; @@ -214,3 +215,65 @@ fn test_bip375_vectors_match_task() { failures.len() ); } + +/// BIP-375 has the Transaction Extractor verify every silent payment output script against the +/// ECDH shares and DLEQ proofs. Each finalize vector must extract once its inputs are finalized, +/// and must not extract once a silent payment output script is tampered with. +#[test] +fn test_bip375_extractor_verifies_sp_output_scripts() { + let secp = Secp256k1::new(); + let vectors = load_vectors(); + let mut failures = Vec::new(); + + for vector in vectors + .valid + .iter() + .filter(|v| v.supplementary.task == Task::Finalize) + { + let psbt = + parse_psbt(&vector.psbt).expect("valid vector must deserialize through rust-psbt"); + let finalized = match Finalizer::new(psbt) + .map_err(|e| format!("{e:?}")) + .and_then(|finalizer| finalizer.finalize(&secp).map_err(|e| format!("{e:?}"))) + { + Ok(finalized) => finalized, + Err(e) => { + failures.push(format!("{}: finalize failed: {e}", vector.description)); + continue; + } + }; + + if let Err(e) = finalized.clone().extract_tx(&secp) { + failures.push(format!("{}: extract failed: {e}", vector.description)); + continue; + } + + let mut tampered = finalized; + let Some(sp_index) = tampered.outputs.iter().position(|o| o.sp_v0_info.is_some()) else { + continue; + }; + let other = (sp_index + 1) % tampered.outputs.len(); + if other == sp_index { + // A single output has nothing to swap with; replace the script instead. + tampered.outputs[sp_index].script_pubkey = bitcoin::ScriptBuf::from_hex( + "51201111111111111111111111111111111111111111111111111111111111111111", + ) + .unwrap(); + } else { + let script = tampered.outputs[other].script_pubkey.clone(); + tampered.outputs[sp_index].script_pubkey = script; + } + let result = tampered.extract_tx(&secp); + if !matches!(result, Err(SpExtractorError::OutputScriptMismatch { .. })) { + failures.push(format!( + "{}: tampered output script must fail with OutputScriptMismatch, got {result:?}", + vector.description + )); + } + } + + for failure in &failures { + println!("FAILED: {failure}"); + } + assert!(failures.is_empty(), "{} vector(s) failed", failures.len()); +} diff --git a/psbt/tests/signer.rs b/psbt/tests/signer.rs index b1116adc..7e268f77 100644 --- a/psbt/tests/signer.rs +++ b/psbt/tests/signer.rs @@ -23,8 +23,7 @@ use bitcoin::{ Amount, CompressedPublicKey, OutPoint, ScriptBuf, Sequence, Transaction, TxOut, Txid, XOnlyPublicKey, }; -use psbt::roles::signer::extract_eligible_input_pubkey; -use psbt::roles::{ShareMode, SpSignerExt}; +use psbt::signer::{ShareMode, SpSignerExt, extract_eligible_input_pubkey}; use psbt_v2::{ Constructor, Creator, Extractor, Finalizer, Input, InputsOnlyModifiable, Output, Psbt, Signer, SpV0Info, @@ -176,15 +175,12 @@ fn sp_p2tr_input( /// Sign input 0 as a BIP-376 silent payment input and write the signature. fn sign_sp_input(psbt: Psbt, spend_sk: &SecretKey, secp: &Secp256k1) -> Psbt { let mut signer = Signer::new(psbt).unwrap(); - let sigs = { - let mut session = signer.session(); - let input = session.signable_input(0).unwrap(); - vec![ - session - .get_silent_payment_sigs(&input, spend_sk, secp) - .unwrap(), - ] - }; + let sigs = signer.session(|mut session| { + let inputs = session.signable_inputs().unwrap(); + vec![session + .get_silent_payment_sigs(&inputs, 0, spend_sk, secp) + .unwrap()] + }); signer.apply(sigs).unwrap() } diff --git a/spdk-wallet/Cargo.toml b/spdk-wallet/Cargo.toml index 89b01d2d..e7044baf 100644 --- a/spdk-wallet/Cargo.toml +++ b/spdk-wallet/Cargo.toml @@ -13,6 +13,7 @@ spdk-core.workspace = true backend-blindbit-v1 = { workspace = true, optional = true } local-scanner = { workspace = true, optional = true, features = ["rayon"] } psbt.workspace = true +psbt-v2.workspace = true anyhow.workspace = true bitcoin.workspace = true diff --git a/spdk-wallet/src/client/coin_select.rs b/spdk-wallet/src/client/coin_select.rs index 3aadf323..53b34e61 100644 --- a/spdk-wallet/src/client/coin_select.rs +++ b/spdk-wallet/src/client/coin_select.rs @@ -43,9 +43,9 @@ fn pool_from_utxos(utxos: &HashMap) -> Result<(Vec, V impl Recipient { /// Returns the output weight in weight units for this recipient. /// - /// For silent-payment recipients the actual script pubkey is not known yet (the key is derived - /// in [`finalize_transaction`]), but the output is always P2TR (`OP_PUSHNUM_1` + 32-byte - /// key = 34 bytes). We build a zero-byte placeholder script of that exact shape and call + /// For silent-payment recipients the actual script pubkey is not known yet (the key is derived in + /// [`commit_sp_outputs`]), but the output is always P2TR (`OP_PUSHNUM_1` + 32-byte key = 34 + /// bytes). We build a zero-byte placeholder script of that exact shape and call /// [`TxOut::weight`] so the bitcoin library owns the arithmetic. /// /// [`finalize_transaction`]: super::SpClient::finalize_transaction diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index 2c9a0107..a6e98f3a 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -1,26 +1,25 @@ -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use anyhow::{Error, Result}; -use bitcoin::absolute::LockTime; -use bitcoin::hashes::Hash as _; -use bitcoin::key::TapTweak as _; -use bitcoin::secp256k1::{Keypair, Message, Secp256k1, rand}; -use bitcoin::sighash::{Prevouts, SighashCache}; -use bitcoin::taproot::Signature; -use bitcoin::transaction::Version; +use bitcoin::bip32::{DerivationPath, Fingerprint}; +use bitcoin::key::rand::rngs::OsRng; +use bitcoin::key::rand::seq::SliceRandom as _; +use bitcoin::key::rand::thread_rng; +use bitcoin::secp256k1::{PublicKey, Secp256k1}; use bitcoin::{ - Amount, Network, OutPoint, ScriptBuf, Sequence, TapLeafHash, Transaction, TxIn, TxOut, Witness, + Amount, CompressedPublicKey, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxOut, }; -use silentpayments::utils::sending::{GlobalSenderEcdhShare, NormalizedSecretKey}; -use silentpayments::{Network as SpNetwork, SilentPaymentCode, utils as sp_utils}; -use silentpayments::{NonEmptyArray, TransactionInputs, TransactionSharedSecret}; - +use psbt::extractor::SpExtractorExt as _; +use psbt::signer::{ShareMode, SpSignerExt as _}; +use psbt_v2::{ + Constructor, Extractor, Finalizer, Input, Modifiable, Output, Psbt, Signer, SpV0Info, +}; +use silentpayments::Network as SpNetwork; use spdk_core::scanner::DiscoveredOutput; use super::coin_select::{pick_utxos_for_fee_rate, select_all_utxos_for_fee_rate}; use super::{ - CoinSelectProposal, DrainSelection, FeeRate, Recipient, RecipientAddress, - SilentPaymentUnsignedTransaction, SpClient, Strategy, + CoinSelectProposal, DrainSelection, FeeRate, Recipient, RecipientAddress, SpClient, }; const fn sp_network_from_network(network: Network) -> SpNetwork { @@ -34,11 +33,11 @@ const fn sp_network_from_network(network: Network) -> SpNetwork { /// Proposes coin selections for a normal (non-drain) transaction. /// /// Runs the `Changeless`, `LowestFee`, and `FeeRateCap` strategies independently -/// and returns one [`InputSelection`] per strategy that found a valid solution. +/// and returns one [`CoinSelectProposal`] per strategy that found a valid solution. /// If none of them succeed, falls back to `Greedy`. /// /// The caller picks the preferred selection and hands it to -/// [`SpClient::create_transaction_from_selection`]. +/// [`SpClient::create_transaction_from_proposal`]. pub fn propose_coin_selections( available_utxos: &HashMap, recipients: &[Recipient], @@ -58,7 +57,7 @@ pub fn propose_coin_selections( /// ```ignore /// let sel = propose_drain_selection(&utxos, &addr, fee_rate)?; /// let recipients = vec![Recipient { address: addr, amount: sel.sent() }]; -/// let unsigned = client.create_drain_transaction_from_selection(&utxos, recipients, &sel, network)?; +/// let unsigned = client.create_drain_transaction_from_selection(&utxos, &recipients, &sel, network)?; /// ``` pub fn propose_drain_selection( available_utxos: &HashMap, @@ -102,7 +101,7 @@ impl SpClient { available_utxos: &HashMap, selected: &[OutPoint], ) -> Result> { - selected + let res = selected .iter() .map(|outpoint| { if let Some(output) = available_utxos.get(outpoint) { @@ -113,49 +112,49 @@ impl SpClient { ))) } }) - .collect() + .collect::>>()?; + if res.len() != selected.len() { + return Err(Error::msg( + "All selected outpoints are not in provided utxos", + )); + } + Ok(res) } - #[expect( - clippy::too_many_arguments, - reason = "private assembler; args map 1:1 to SilentPaymentUnsignedTransaction fields" - )] fn assemble_unsigned( &self, available_utxos: &HashMap, selected_outpoints: &[OutPoint], - recipients: Vec, + recipients: &[Recipient], network: Network, - change: Amount, - change_index: Option, - fee: Amount, - actual_fee_rate: FeeRate, - strategy: Option, - ) -> Result { - Self::validate_recipient_networks(&recipients, network)?; + ) -> Result { + Self::validate_recipient_networks(recipients, network)?; let selected_utxos = Self::resolve_selected_utxos(available_utxos, selected_outpoints)?; - let shared_secrets = - self.build_shared_secrets_for_sp_transaction(&selected_utxos, &recipients)?; + let spend_pubkey = CompressedPublicKey(PublicKey::from(&self.spend_key())); - Ok(SilentPaymentUnsignedTransaction { - selected_utxos, - recipients, - shared_secrets, - unsigned_tx: None, - network, - change, - change_index, - fee, - actual_fee_rate, - strategy, - }) + // Inputs and outputs are fixed by coin selection. Freeze them here so a + // later ECDH share cannot be computed against a different input set. + let mut constructor = Constructor::::default(); + for (outpoint, output) in &selected_utxos { + constructor = constructor.input(input_for_utxo(spend_pubkey, outpoint, output)); + } + for recipient in recipients { + constructor = constructor.output(output_for_recipient(recipient, network)?)?; + } + Ok(constructor.no_more_inputs().no_more_outputs().psbt()?) } - /// Builds an unsigned silent-payment transaction from a payment [`InputSelection`]. + /// Builds an unsigned silent-payment PSBT from a payment [`CoinSelectProposal`]. /// /// Pass the original `recipients` without a change output; if - /// `selection.change() > 0` this method appends a change output addressed - /// to the wallet's own SP change address. + /// `selection.change() > 0` this method appends a change output + /// addressed to the wallet's own SP change code, then shuffles the + /// recipient order so change is not always last. + /// + /// Silent-payment outputs are returned with an empty `script_pubkey` and + /// `sp_v0_info` set. [`Self::commit_sp_outputs`] derives the scripts. + /// Fee, fee rate, and the coin-selection strategy are not stored on the PSBT; + /// the fee is the difference between input and output amounts. /// /// The passed `recipients` must be the ones the selection was computed for: /// their total amount must equal `selection.sent()` and their count @@ -166,7 +165,7 @@ impl SpClient { mut recipients: Vec, selection: &CoinSelectProposal, network: Network, - ) -> Result { + ) -> Result { let total_outputs_amt: Amount = recipients.iter().map(|r| r.amount).sum(); if total_outputs_amt != selection.sent() { return Err(Error::msg( @@ -186,41 +185,37 @@ impl SpClient { )); } - let (wallet_change, change_index) = if selection.change() > Amount::ZERO { - let change_index = recipients.len(); + // Check that there's no duplicate selection + let selected_utxos = selection.selected_utxos(); + let mut selected_seen = HashSet::with_capacity(selected_utxos.len()); + for outpoint in selected_utxos { + if !selected_seen.insert(outpoint) { + return Err(Error::msg("Duplicate outpoint in selected_utxos")); + } + } + + if selection.change() > Amount::ZERO { recipients.push(Recipient { address: RecipientAddress::SpCode(self.sp_receiver.change_code()), amount: selection.change(), }); - (selection.change(), Some(change_index)) - } else { - (Amount::ZERO, None) - }; + } + recipients.shuffle(&mut thread_rng()); - self.assemble_unsigned( - available_utxos, - selection.selected_utxos(), - recipients, - network, - wallet_change, - change_index, - selection.fee(), - selection.actual_fee_rate(), - Some(selection.strategy()), - ) + self.assemble_unsigned(available_utxos, selected_utxos, &recipients, network) } - /// Builds an unsigned drain transaction from a [`DrainSelection`]. + /// Builds an unsigned drain PSBT from a [`DrainSelection`]. /// /// The caller must pass the drain recipient(s) with total amount equal to /// `selection.sent()`. No change output is appended. pub fn create_drain_transaction_from_selection( &self, available_utxos: &HashMap, - recipients: Vec, + recipients: &[Recipient], selection: &DrainSelection, network: Network, - ) -> Result { + ) -> Result { let total_outputs_amt: Amount = recipients.iter().map(|r| r.amount).sum(); if total_outputs_amt != selection.sent() { return Err(Error::msg( @@ -245,264 +240,169 @@ impl SpClient { selection.selected_utxos(), recipients, network, - Amount::ZERO, - None, - selection.fee(), - selection.actual_fee_rate(), - None, ) } - /// Resolves silent-payment placeholder outputs to their final script - /// pubkeys and assembles the [`Transaction`] skeleton (no witnesses yet). - pub fn finalize_transaction( - mut unsigned_transaction: SilentPaymentUnsignedTransaction, - ) -> Result { - let tx_ins: Vec = unsigned_transaction - .selected_utxos - .iter() - .map(|(outpoint, _)| TxIn { - previous_output: *outpoint, - script_sig: ScriptBuf::new(), - sequence: Sequence::MAX, - witness: Witness::new(), - }) - .collect(); - - let recipient_codes: Vec = unsigned_transaction - .recipients - .iter() - .filter_map(|r| match &r.address { - RecipientAddress::SpCode(sp_code) => Some(*sp_code), - _ => None, - }) - .collect(); + /// Derives silent-payment output scripts and writes them onto `psbt`. + /// + /// BIP-375 requires the Signer to do this before adding any signature. + /// Adds a global ECDH share (this wallet owns every input) when none is + /// present, then commits the scripts. A PSBT with no silent-payment outputs + /// is returned unchanged. Requires the spend secret when shares are missing. + pub fn commit_sp_outputs(&self, mut psbt: Psbt) -> Result { + let mut pending = false; + let mut committed = false; + for output in &psbt.outputs { + if output.sp_v0_info.is_none() { + continue; + } + if output.script_pubkey.is_empty() { + pending = true; + } else { + committed = true; + } + } + if pending && committed { + return Err(Error::msg( + "silent payment outputs are only partially derived", + )); + } + if !pending { + return Ok(psbt); + } let secp = Secp256k1::new(); - - let sp_key_material2xonlypubkeys = silentpayments::sending::generate_recipient_pubkeys( - &secp, - &recipient_codes, - &unsigned_transaction.shared_secrets, - )?; - - let tx_outs = unsigned_transaction - .recipients - .iter() - .map(|recipient| match &recipient.address { - RecipientAddress::SpCode(s) => { - let pubkeys = sp_key_material2xonlypubkeys - .get(s) - .ok_or(Error::msg("Unknown silent payment key material"))?; - - // we currently only allow having 1 output per silent payment address - // note: when changing this, it should also be accounted for in - // 'create_transaction_from_selection' - if pubkeys.len() == 1 { - let pubkey = pubkeys[0]; - let script = ScriptBuf::new_p2tr_tweaked(pubkey.dangerous_assume_tweaked()); - Ok(TxOut { - value: recipient.amount, - script_pubkey: script, - }) - } else { - Err(Error::msg("multiple outputs not supported")) - } - } - RecipientAddress::LegacyAddress(unchecked_address) => { - let script = unchecked_address - .clone() - .require_network(unsigned_transaction.network)? - .script_pubkey(); - - Ok(TxOut { - value: recipient.amount, - script_pubkey: script, - }) - } - RecipientAddress::Data(data) => { - if recipient.amount > Amount::from_sat(0) { - return Err(Error::msg("Data output must have an amount of 0!")); - } - let script = ScriptBuf::new_op_return(data); - Ok(TxOut { - value: recipient.amount, - script_pubkey: script, - }) - } - }) - .collect::>>()?; - - let tx = Transaction { - version: Version::TWO, - lock_time: LockTime::ZERO, - input: tx_ins, - output: tx_outs, - }; - unsigned_transaction.unsigned_tx = Some(tx); - Ok(unsigned_transaction) + let shares_present = !psbt.global.sp_ecdh_shares.is_empty() + || psbt + .inputs + .iter() + .any(|input| !input.sp_ecdh_shares.is_empty()); + if !shares_present { + let spend_sk = self.try_secret_spend_key()?; + let mut rng = OsRng; + psbt.add_ecdh_shares(&secp, &mut rng, &spend_sk, ShareMode::Global)?; + } + psbt.commit_sp_outputs(&secp)?; + Ok(psbt) } - fn taproot_sighash< - T: std::ops::Deref + std::borrow::Borrow, - >( - hash_ty: bitcoin::TapSighashType, - prevouts: &[TxOut], - input_index: usize, - cache: &mut SighashCache, - tapleaf_hash: Option, - ) -> Result { - let prevouts = Prevouts::All(prevouts); - - let sighash = match tapleaf_hash { - Some(leaf_hash) => cache.taproot_script_spend_signature_hash( - input_index, - &prevouts, - leaf_hash, - hash_ty, - )?, - None => cache.taproot_key_spend_signature_hash(input_index, &prevouts, hash_ty)?, - }; - let msg = Message::from_digest(sighash.to_byte_array()); - Ok(msg) + /// Signs every input this wallet can sign. Does not finalize witnesses. + /// + /// Silent-payment output scripts must already be set. BIP-375 forbids a + /// signature while any of them is still empty. + pub fn sign_inputs(&self, psbt: Psbt) -> Result { + let spend_sk = self.try_secret_spend_key()?; + let secp = Secp256k1::new(); + let input_count = psbt.inputs.len(); + let mut signer = Signer::new(psbt)?; + // Every wallet input is a BIP-376 spend. The default Taproot sighash commits to + // every prevout, so the inputs have to be validated as one set. + let sigs = signer.session(|mut session| -> Result> { + let inputs = session.signable_inputs().map_err(|errors| { + Error::msg( + errors + .iter() + .map(|(index, error)| format!("input {index}: {error}")) + .collect::>() + .join(", "), + ) + })?; + (0..input_count) + .map(|index| { + session + .get_silent_payment_sigs(&inputs, index, &spend_sk, &secp) + .map_err(Error::from) + }) + .collect() + })?; + Ok(signer.apply(sigs)?) } - pub fn sign_transaction( - &self, - unsigned_tx: &SilentPaymentUnsignedTransaction, - aux_rand: &[u8; 32], - ) -> Result { - // TODO check that we have aux_rand, at least that it's not all `0`s - let b_spend = self.try_secret_spend_key()?; - - let Some(to_sign) = unsigned_tx.unsigned_tx.as_ref() else { - return Err(Error::msg("Missing unsigned transaction")); - }; - - let mut signed = to_sign.clone(); - - let mut cache = SighashCache::new(to_sign); - - let prevouts: Vec<_> = unsigned_tx - .selected_utxos - .iter() - .map(|(_, o)| o.txout.clone()) - .collect(); - - let secp = Secp256k1::signing_only(); - let sighash_type = bitcoin::TapSighashType::Default; // We impose Default for now - - for (i, input) in to_sign.input.iter().enumerate() { - let tap_leaf_hash: Option = None; - - let msg = Self::taproot_sighash(sighash_type, &prevouts, i, &mut cache, tap_leaf_hash)?; - - let (_, owned_output) = unsigned_tx - .selected_utxos - .iter() - .find(|(o, _)| o == &input.previous_output) - .ok_or_else(|| { - Error::msg(format!("prevout for input {i} not in selected utxos")) - })?; - - let sk = b_spend.add_tweak(&owned_output.tweak)?; - - let keypair = Keypair::from_secret_key(&secp, &sk); - - let signature = secp.sign_schnorr_with_aux_rand(&msg, &keypair, aux_rand); - - let mut witness = Witness::new(); - witness.push( - Signature { - signature, - sighash_type, - } - .to_vec(), - ); - - signed.input[i].witness = witness; - } - - Ok(signed) + /// Builds each input's final scriptSig and witness from its signatures. + /// + /// This is the Input Finalizer. It clears the fields the Signer reads input + /// public keys from, which is why [`Self::verify_sp_output_scripts`] recovers + /// those keys from the witness. + pub fn finalize_inputs(&self, psbt: Psbt) -> Result { + let secp = Secp256k1::new(); + Ok(Finalizer::new(psbt)?.finalize(&secp)?) } - fn taproot_input_pubkey( - script_pubkey: &ScriptBuf, - ) -> Result { - use silentpayments::secp256k1::{Parity, PublicKey, XOnlyPublicKey}; - let xonly = XOnlyPublicKey::from_slice(&script_pubkey.as_bytes()[2..])?; - Ok(PublicKey::from_x_only_public_key(xonly, Parity::Even)) + /// Recomputes silent-payment output scripts from the finalized inputs and + /// rejects a mismatch. + /// + /// BIP-375 assigns this to the Transaction Extractor. The input public keys + /// are recovered from the final scriptSig and witness, so + /// [`Self::finalize_inputs`] has to have run already. + pub fn verify_sp_output_scripts(&self, psbt: &Psbt) -> Result<()> { + let secp = Secp256k1::new(); + Ok(psbt.verify_sp_output_scripts(&secp)?) } - fn sp_recipient_scan_keys( - recipients: &[Recipient], - ) -> Vec { - let mut keys = Vec::new(); - for recipient in recipients { - if let RecipientAddress::SpCode(sp_code) = &recipient.address { - let scan_key = sp_code.scan_key(); - if !keys.iter().any(|k| k == &scan_key) { - keys.push(scan_key); - } - } - } - keys + /// Extracts the transaction. Does not repeat [`Self::verify_sp_output_scripts`]. + pub fn extract_transaction(&self, psbt: Psbt) -> Result { + Ok(Extractor::new(psbt)?.extract_tx()?) } +} - fn build_shared_secrets_for_sp_transaction( - &self, - selected_utxos: &[(OutPoint, DiscoveredOutput)], - recipients: &[Recipient], - ) -> Result> { - let recipient_scan_keys = Self::sp_recipient_scan_keys(recipients); - if recipient_scan_keys.is_empty() { - return Ok(HashMap::new()); - } +fn input_for_utxo( + spend_pubkey: CompressedPublicKey, + outpoint: &OutPoint, + output: &DiscoveredOutput, +) -> Input { + let mut input = Input::new(outpoint); + input.sequence = Some(Sequence::MAX); + input.witness_utxo = Some(output.txout.clone()); + // BIP-376: the map key is the untweaked spend key. The output key on the + // prevout is `spend_pubkey + tweak·G`. + input.sp_tweak = Some(output.tweak.to_be_bytes()); + input.sp_spend_bip32_derivations.insert( + spend_pubkey, + (Fingerprint::default(), DerivationPath::master()), + ); + input +} - let secp = Secp256k1::new(); - let b_spend = self.try_secret_spend_key()?; - - let mut inputs = TransactionInputs::new(); - let mut normalized_keys = Vec::with_capacity(selected_utxos.len()); - for (outpoint, output) in selected_utxos { - let sp_outpoint = sp_utils::OutPoint::from_txid_bytes_and_vout( - outpoint.txid.to_byte_array(), - outpoint.vout, - ); - let pubkey = Self::taproot_input_pubkey(&output.txout.script_pubkey)?; - inputs.push( - sp_outpoint, - output.txout.script_pubkey.as_bytes().to_vec(), - Some(pubkey), - ); - let sk = b_spend.add_tweak(&output.tweak)?; - normalized_keys.push(NormalizedSecretKey::new(&secp, sk, true)); +fn output_for_recipient(recipient: &Recipient, network: Network) -> Result { + match &recipient.address { + RecipientAddress::SpCode(code) => { + let mut output = Output::new(TxOut { + value: recipient.amount, + script_pubkey: ScriptBuf::new(), + }); + output.sp_v0_info = Some(SpV0Info::new( + CompressedPublicKey(code.scan_key()), + CompressedPublicKey(code.m_pubkey()), + )); + Ok(output) } - - let mut aux_rand = [0u8; 32]; - rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut aux_rand); - - let mut shared_secrets = HashMap::new(); - for recipient_scan_key in recipient_scan_keys { - let global_share = GlobalSenderEcdhShare::new_from_summed_keys( - &secp, - recipient_scan_key, - NonEmptyArray::new(&normalized_keys).expect("non-empty inputs"), - &aux_rand, - )?; - shared_secrets.insert( - recipient_scan_key, - TransactionSharedSecret::new_from_global_share(&secp, &global_share, &inputs)?, - ); + RecipientAddress::LegacyAddress(unchecked_address) => { + let script_pubkey = unchecked_address + .clone() + .require_network(network)? + .script_pubkey(); + Ok(Output::new(TxOut { + value: recipient.amount, + script_pubkey, + })) + } + RecipientAddress::Data(data) => { + if recipient.amount > Amount::ZERO { + return Err(Error::msg("Data output must have an amount of 0!")); + } + Ok(Output::new(TxOut { + value: recipient.amount, + script_pubkey: ScriptBuf::new_op_return(data), + })) } - - Ok(shared_secrets) } } #[cfg(test)] mod tests { - use bitcoin::secp256k1::{Scalar, SecretKey}; + use bitcoin::hashes::Hash as _; + use bitcoin::key::TapTweak as _; + use bitcoin::secp256k1::{Keypair, Scalar, SecretKey}; use bitcoin::{Address, Txid}; use super::*; @@ -523,7 +423,7 @@ mod tests { } // The output key must match `spend_sk + tweak`, otherwise the DLEQ proof - // generated at shared-secret build time cannot verify. + // generated when committing silent-payment outputs cannot verify. fn discovered_output(spend_sk: &SecretKey, value_sat: u64) -> DiscoveredOutput { let secp = Secp256k1::new(); let tweak = Scalar::ONE; @@ -591,7 +491,7 @@ mod tests { .find(|s| s.change() > Amount::ZERO) .expect("a selection with change"); - let unsigned = client + let psbt = client .create_transaction_from_proposal( &utxos, recipients.clone(), @@ -600,9 +500,31 @@ mod tests { ) .expect("transaction"); - assert_eq!(unsigned.recipients.len(), recipients.len() + 1); - assert_eq!(unsigned.change_index, Some(recipients.len())); - assert_eq!(unsigned.change, unsigned.recipients.last().unwrap().amount); + assert_eq!(psbt.outputs.len(), recipients.len() + 1); + let change = psbt + .outputs + .iter() + .find(|o| o.amount == selection.change() && o.sp_v0_info.is_some()) + .expect("change output"); + assert!(change.script_pubkey.is_empty()); + + let psbt = client.commit_sp_outputs(psbt).expect("commit"); + let change_vout = psbt + .outputs + .iter() + .position(|o| o.amount == selection.change() && o.sp_v0_info.is_some()) + .expect("change output"); + assert!(psbt.outputs[change_vout].script_pubkey.is_p2tr()); + + let psbt = client.sign_inputs(psbt).expect("sign"); + let psbt = client.finalize_inputs(psbt).expect("finalize"); + client + .verify_sp_output_scripts(&psbt) + .expect("verify outputs"); + let tx = client.extract_transaction(psbt).expect("extract"); + assert_eq!(tx.output.len(), recipients.len() + 1); + assert!(tx.output[change_vout].script_pubkey.is_p2tr()); + assert!(tx.input.iter().all(|input| !input.witness.is_empty())); } #[test] @@ -657,22 +579,31 @@ mod tests { address: drain_address, amount: selection.sent(), }]; - let unsigned = client + let psbt = client .create_drain_transaction_from_selection( &utxos, - recipients, + &recipients, &selection, Network::Regtest, ) .expect("transaction"); - assert_eq!(unsigned.recipients.len(), 1); - assert_eq!(unsigned.change, Amount::ZERO); - assert_eq!(unsigned.change_index, None); - assert_eq!(unsigned.strategy, None); + assert_eq!(psbt.outputs.len(), 1); + assert!(psbt.outputs[0].sp_v0_info.is_none()); + assert_eq!(psbt.outputs[0].amount, selection.sent()); assert_eq!( - unsigned.recipients[0].amount + unsigned.fee, + psbt.outputs[0].amount + selection.fee(), Amount::from_sat(300_000) ); + + let psbt = client.commit_sp_outputs(psbt).expect("commit"); + let psbt = client.sign_inputs(psbt).expect("sign"); + let psbt = client.finalize_inputs(psbt).expect("finalize"); + client + .verify_sp_output_scripts(&psbt) + .expect("verify outputs"); + let tx = client.extract_transaction(psbt).expect("extract"); + assert_eq!(tx.output.len(), 1); + assert!(tx.input.iter().all(|input| !input.witness.is_empty())); } } diff --git a/spdk-wallet/src/client/structs.rs b/spdk-wallet/src/client/structs.rs index b909eaf7..8494707f 100644 --- a/spdk-wallet/src/client/structs.rs +++ b/spdk-wallet/src/client/structs.rs @@ -1,4 +1,3 @@ -use std::collections::HashMap; use std::str::FromStr as _; use anyhow::Error; @@ -9,15 +8,9 @@ use bitcoin::hex::{DisplayHex as _, FromHex as _}; use bitcoin::key::Secp256k1; use bitcoin::script::PushBytesBuf; use bitcoin::secp256k1::{PublicKey, SecretKey}; -use bitcoin::{Address, Amount, Network, OutPoint, Transaction}; +use bitcoin::{Address, Amount}; use serde::{Deserialize, Serialize}; use silentpayments::SilentPaymentCode; -use silentpayments::TransactionSharedSecret; -use silentpayments::secp256k1::PublicKey as SpPublicKey; - -use spdk_core::scanner::DiscoveredOutput; - -use super::coin_select::Strategy; #[derive(Debug, Clone, PartialEq)] pub enum RecipientAddress { @@ -60,24 +53,6 @@ pub struct Recipient { pub amount: Amount, // must be 0 if address is Data. } -#[derive(Debug, Clone)] -// this will be replaced by a proper psbt as soon as sp support is standardised -pub struct SilentPaymentUnsignedTransaction { - pub selected_utxos: Vec<(OutPoint, DiscoveredOutput)>, - pub recipients: Vec, - pub shared_secrets: HashMap, - pub unsigned_tx: Option, - pub network: Network, - /// Wallet change amount (zero for drain / changeless selections). - pub change: Amount, - /// Index into `recipients` of the change output, if any. - pub change_index: Option, - pub fee: Amount, - pub actual_fee_rate: FeeRate, - /// Coin-selection strategy used for a payment; `None` for drain transactions. - pub strategy: Option, -} - #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)] pub enum SpendKey { Secret(SecretKey), diff --git a/spdk-wallet/src/lib.rs b/spdk-wallet/src/lib.rs index 71cb0f67..fa3830e5 100644 --- a/spdk-wallet/src/lib.rs +++ b/spdk-wallet/src/lib.rs @@ -11,6 +11,8 @@ pub use bitcoin; // re-export local scanner if enabled #[cfg(feature = "local-scanner")] pub use local_scanner::SpScanner; -pub use psbt; +// BIP-375 extensions. The PSBT type and upstream roles come from psbt_v2. +pub use psbt::{extractor, signer}; +pub use psbt_v2; pub use silentpayments; pub use spdk_core::{chain, scanner}; From 34a418b379b8f619730a93ccf51987c335c1f912 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Fri, 16 Oct 2026 22:17:05 +0200 Subject: [PATCH 09/13] fix(psbt): refuse to sign silent payments the receiver cannot scan A co-sender can hand us a PSBT we would sign and a receiver would skip, or swap an output script after the shares are written. Either way the signature can be broadcast before we notice. Uncompressed P2PKH keys are left out of the ECDH sum, matching BIP-352. A P2SH input now needs a redeem script that hashes to its prevout before we decide whether it is P2SH-P2WPKH; a missing or mismatched script is an error rather than a skipped input. Signing goes through rust-psbt 2fb5abc, whose session takes a verifier and the exact input set. SpOutputVerifier re-derives the output scripts from the verified shares and rejects an empty or swapped script. A witness-only prevout is also rejected unless one of the inputs being signed is P2TR, because only that signature commits to every prevout. The wallet runs the same check when scripts are already set, and passes every input index because it signs them all. --- Cargo.toml | 2 +- psbt/src/signer.rs | 174 +++++++- psbt/tests/signer.rs | 681 ++++++++++++++++++++++++++++++-- spdk-wallet/src/client/spend.rs | 105 ++++- 4 files changed, 904 insertions(+), 58 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bf67be63..97b366d5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,7 +38,7 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } -psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "fceb052fa0a4a35f6ddda823d5b9c17f945a9078", features = ["silent-payments", "miniscript"] } +psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "2fb5abceaee36d3a72885a3fe21a2f630220f000", features = ["silent-payments", "miniscript"] } # DLEQ (BIP-374) backend decision (2026-09): # We use rust-dleq's pure-Rust `standalone` backend (the default in `silentpayments` # and `psbt`), pinned to this fork. It is verified against the official BIP-374 diff --git a/psbt/src/signer.rs b/psbt/src/signer.rs index 786e1436..fa4f5a94 100644 --- a/psbt/src/signer.rs +++ b/psbt/src/signer.rs @@ -12,7 +12,9 @@ //! Signing itself is *not* re-implemented here: open an upstream `Signer::session`, //! produce signatures with `SigningSession::get_input_sigs` (ECDSA and plain taproot //! key spends) or `SigningSession::get_silent_payment_sigs` (BIP-376 inputs), then -//! write them with `Signer::apply`. +//! write them with `Signer::apply`. Call [`SpSignerExt::verify_before_signing`] on the +//! PSBT first: upstream signing does not check that the output scripts follow from the +//! shares. use std::collections::HashMap; use std::fmt; @@ -21,7 +23,7 @@ use bitcoin::key::TweakedPublicKey; use bitcoin::{CompressedPublicKey, ScriptBuf, XOnlyPublicKey}; use psbt_v2::{ CommitSilentPaymentOutputsError, DetermineLockTimeError, FundingUtxoError, GetKey, Input, - KeyRequest, Psbt, Signer as UpstreamSigner, SpV0Info, + KeyRequest, Psbt, SilentPaymentVerifier, Signer as UpstreamSigner, SpV0Info, }; use secp256k1::rand::{CryptoRng, RngCore}; use secp256k1::{Parity, PublicKey, Scalar, Secp256k1, SecretKey, Signing, Verification}; @@ -44,6 +46,14 @@ pub enum SpSignerError { /// will learn it from the finalized witness, so deriving without it would /// commit to the wrong input set. MissingInputPubkey { vin: usize }, + /// A P2SH input has no `redeem_script`. Whether it is P2SH-P2WPKH, and so contributes to the + /// ECDH, is only knowable from the redeem script, which the receiver reads from the final + /// scriptSig. + MissingRedeemScript { vin: usize }, + /// The declared `redeem_script` does not hash to the P2SH funding script. The receiver uses + /// the redeem script from the final scriptSig, so a declared script that does not match the + /// prevout cannot be used to decide whether the input contributes. + RedeemScriptMismatch { vin: usize }, /// No ECDH share for this scan key on the given input. MissingShare { scan_key: CompressedPublicKey, @@ -81,6 +91,12 @@ pub enum SpSignerError { DetermineLockTime(DetermineLockTimeError), /// Upstream `commit_silent_payment_outputs` rejected the derived scripts. CommitOutputs(CommitSilentPaymentOutputsError), + /// A silent payment output script is empty or differs from the one derived from the + /// verified ECDH shares. + OutputScriptMismatch { index: usize }, + /// Another signer's funding output is only known from `witness_utxo`, and none of the inputs + /// being signed is P2TR, so no signature would commit to its script. + UnverifiedPrevout { vin: usize }, } impl fmt::Display for SpSignerError { @@ -92,6 +108,14 @@ impl fmt::Display for SpSignerError { f, "input {vin}: BIP-352 eligible but its pubkey cannot be named from the PSBT" ), + E::MissingRedeemScript { vin } => write!( + f, + "input {vin}: P2SH without a redeem script, cannot tell whether it is P2SH-P2WPKH" + ), + E::RedeemScriptMismatch { vin } => write!( + f, + "input {vin}: redeem script does not hash to the P2SH funding script" + ), E::MissingShare { scan_key, vin } => { write!(f, "no ECDH share for scan key {scan_key} on input {vin}") } @@ -126,6 +150,14 @@ impl fmt::Display for SpSignerError { E::Secp256k1(e) => write!(f, "secp256k1 error: {e}"), E::DetermineLockTime(e) => write!(f, "cannot determine lock time: {e}"), E::CommitOutputs(e) => write!(f, "failed to commit silent payment outputs: {e}"), + E::OutputScriptMismatch { index } => write!( + f, + "output {index}: silent payment script does not match the verified ECDH shares" + ), + E::UnverifiedPrevout { vin } => write!( + f, + "input {vin}: funding output unverified and not committed to by any signed input" + ), } } } @@ -232,6 +264,35 @@ pub trait SpSignerExt { fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> where C: Signing + Verification; + + /// BIP-375 signer gate: checks that the silent payment output scripts can be signed. + /// + /// Must run on the exact PSBT passed to `Signer::new`. Upstream signing only checks that the + /// scripts are set, not that they follow from the shares. + /// + /// `signed_vins` are the inputs about to be signed. The other signers' funding outputs are + /// claims, and a legacy or SegWit v0 signature only commits to its own input's script. A + /// P2TR signature with `SIGHASH_DEFAULT` or `SIGHASH_ALL` (the only types BIP-375 allows) + /// commits to every prevout script, so an unverifiable funding output of another signer is + /// accepted only when one of `signed_vins` is P2TR. + /// + /// No-op when the PSBT has no SP outputs. + /// + /// # Errors + /// + /// - Any error of [`Self::derive_sp_output_scripts`], including a failed DLEQ proof. + /// - [`SpSignerError::OutputScriptMismatch`] if an SP output script is empty or differs from + /// the derived one. + /// - [`SpSignerError::UnverifiedPrevout`] if an input outside `signed_vins` has no + /// `non_witness_utxo` and none of `signed_vins` is P2TR. + /// - [`SpSignerError::MalformedInput`] if a signed index is out of range. + fn verify_before_signing( + &self, + secp: &Secp256k1, + signed_vins: &[usize], + ) -> Result<(), SpSignerError> + where + C: Signing + Verification; } impl SpSignerExt for Psbt { @@ -278,7 +339,7 @@ impl SpSignerExt for Psbt { let mut summed_keys: Vec = Vec::with_capacity(self.inputs.len()); for (vin, input) in self.inputs.iter().enumerate() { - if !is_ecdh_contributing(input)? { + if !is_ecdh_contributing(input, vin)? { continue; } let input_key = resolve_owned_eligible_key(secp, input, vin, keys)? @@ -390,8 +451,8 @@ impl SpSignerExt for Psbt { input.spent_output_index, )?; let spk = funding_output(input)?.script_pubkey.to_bytes(); - let pubkey = extract_eligible_input_pubkey(input)?; - if pubkey.is_none() && is_ecdh_contributing(input)? { + let pubkey = extract_eligible_input_pubkey(input, vin)?; + if pubkey.is_none() && is_ecdh_contributing(input, vin)? { return Err(SpSignerError::MissingInputPubkey { vin }); } transaction_inputs.push(outpoint, spk, pubkey); @@ -413,6 +474,62 @@ impl SpSignerExt for Psbt { *self = signer.psbt(); Ok(()) } + + fn verify_before_signing( + &self, + secp: &Secp256k1, + signed_vins: &[usize], + ) -> Result<(), SpSignerError> + where + C: Signing + Verification, + { + if self + .outputs + .iter() + .all(|output| output.sp_v0_info.is_none()) + { + return Ok(()); + } + + for (index, script) in self.derive_sp_output_scripts(secp)? { + if self.outputs[index].script_pubkey != script { + return Err(SpSignerError::OutputScriptMismatch { index }); + } + } + + let mut signs_p2tr = false; + for &vin in signed_vins { + let input = self.inputs.get(vin).ok_or(SpSignerError::MalformedInput { + vin, + detail: "signed input index out of range", + })?; + signs_p2tr |= funding_output(input)?.script_pubkey.is_p2tr(); + } + if !signs_p2tr { + // The claimed script type is itself unverified, so a witness-only P2TR claim counts. + if let Some(vin) = (0..self.inputs.len()).find(|vin| { + !signed_vins.contains(vin) && self.inputs[*vin].non_witness_utxo.is_none() + }) { + return Err(SpSignerError::UnverifiedPrevout { vin }); + } + } + Ok(()) + } +} + +/// [`SilentPaymentVerifier`] for [`psbt_v2::Signer::session`]. +/// +/// Runs [`SpSignerExt::verify_before_signing`] for the inputs the session will sign. +pub struct SpOutputVerifier<'a, C: Signing + Verification> { + pub secp: &'a Secp256k1, +} + +impl SilentPaymentVerifier for SpOutputVerifier<'_, C> { + type Error = SpSignerError; + + fn verify(&self, psbt: &Psbt, signed_inputs: &[usize]) -> Result<(), Self::Error> { + psbt.verify_before_signing(self.secp, signed_inputs) + } } /// Derives the silent payment output scripts from the PSBT's ECDH shares. @@ -612,7 +729,8 @@ fn collect_sp_v0_keys(psbt: &Psbt) -> Vec<(usize, SpV0Info)> { /// `tap_merkle_root` retweaks that key to the funding scriptPubKey (BIP-352 §3). A NUMS claim /// that does not reproduce the prevout is still eligible. SP inputs (`sp_tweak` set) always have /// a key path, so the exception does not apply to them. -/// - **P2WPKH / P2PKH**: reads from `bip32_derivations`. +/// - **P2WPKH / P2PKH**: reads from `bip32_derivations`. Only a compressed key is returned: a +/// P2PKH output committing to an uncompressed key does not contribute (BIP-352). /// - **P2SH-P2WPKH**: checks that `redeem_script` is P2WPKH, then reads from `bip32_derivations`. /// /// Returns `Ok(None)` when the input does not contribute to the ECDH, when the required @@ -620,8 +738,17 @@ fn collect_sp_v0_keys(psbt: &Psbt) -> Vec<(usize, SpV0Info)> { /// funding script. Callers that require a pubkey for every contributing input (share /// generation in [`ShareMode::Global`], output derivation) must turn that `None` into an /// error themselves. -pub fn extract_eligible_input_pubkey(input: &Input) -> Result, SpSignerError> { - if !is_ecdh_contributing(input)? { +/// +/// # Errors +/// +/// [`SpSignerError::MissingRedeemScript`] for a P2SH input without `redeem_script`. +/// [`SpSignerError::RedeemScriptMismatch`] when `redeem_script` does not hash to the P2SH +/// funding script. +pub fn extract_eligible_input_pubkey( + input: &Input, + vin: usize, +) -> Result, SpSignerError> { + if !is_ecdh_contributing(input, vin)? { return Ok(None); } @@ -662,15 +789,36 @@ pub fn extract_eligible_input_pubkey(input: &Input) -> Result, /// key path. /// /// P2SH contributes only as P2SH-P2WPKH, which is only knowable from the redeem -/// script — a bare P2SH input (or one without `redeem_script` set yet) is -/// treated as non-contributing. -fn is_ecdh_contributing(input: &Input) -> Result { +/// script. A P2SH input without `redeem_script` is an error: the signer needs the +/// redeem script to know whether the input contributes. A redeem script that does +/// not hash to the funding script is also an error. The receiver uses the redeem +/// script pushed in the final scriptSig, which has to match the prevout. +/// +/// A P2PKH output committing to an uncompressed key does not contribute. The script +/// hash alone does not reveal the key encoding, so this is only known when +/// `bip32_derivations` declares the uncompressed key that matches the script. +fn is_ecdh_contributing(input: &Input, vin: usize) -> Result { let spk = &funding_output(input)?.script_pubkey; if !is_eligible(spk.as_bytes()) { return Ok(false); } if spk.is_p2sh() { - return Ok(input.redeem_script.as_ref().is_some_and(|r| r.is_p2wpkh())); + let redeem_script = input + .redeem_script + .as_ref() + .ok_or(SpSignerError::MissingRedeemScript { vin })?; + if ScriptBuf::new_p2sh(&redeem_script.script_hash()) != *spk { + return Err(SpSignerError::RedeemScriptMismatch { vin }); + } + return Ok(redeem_script.is_p2wpkh()); + } + if spk.is_p2pkh() + && input + .bip32_derivations + .keys() + .any(|pk| !pk.compressed && ScriptBuf::new_p2pkh(&pk.pubkey_hash()) == *spk) + { + return Ok(false); } if spk.is_p2tr() && input.sp_tweak.is_none() && is_nums_script_path_only(input, spk) { return Ok(false); @@ -853,7 +1001,7 @@ fn pubkey_matches_funding_script( .is_ok_and(|h| ScriptBuf::new_p2wpkh(&h) == *spk); } if spk.is_p2pkh() { - return ScriptBuf::new_p2pkh(&pubkey.pubkey_hash()) == *spk; + return pubkey.compressed && ScriptBuf::new_p2pkh(&pubkey.pubkey_hash()) == *spk; } if spk.is_p2sh() { let Some(redeem) = redeem_script else { diff --git a/psbt/tests/signer.rs b/psbt/tests/signer.rs index 7e268f77..d27a88ac 100644 --- a/psbt/tests/signer.rs +++ b/psbt/tests/signer.rs @@ -12,6 +12,8 @@ //! input. //! 7. Receiver-verified end-to-end: the recipient can scan the derived SP outputs (single-signer //! with an SP input, and two-party multi-signer aggregation). +//! 8. Inputs the signer and the receiver disagree on: an uncompressed P2PKH key, and a non-P2TR +//! funding UTXO given only as `witness_utxo`. use std::collections::HashSet; @@ -23,14 +25,16 @@ use bitcoin::{ Amount, CompressedPublicKey, OutPoint, ScriptBuf, Sequence, Transaction, TxOut, Txid, XOnlyPublicKey, }; -use psbt::signer::{ShareMode, SpSignerExt, extract_eligible_input_pubkey}; +use psbt::signer::{ + ShareMode, SpOutputVerifier, SpSignerError, SpSignerExt, extract_eligible_input_pubkey, +}; use psbt_v2::{ - Constructor, Creator, Extractor, Finalizer, Input, InputsOnlyModifiable, Output, Psbt, Signer, - SpV0Info, + Constructor, Creator, Extractor, Finalizer, Input, InputsOnlyModifiable, Output, Psbt, + SignError, Signer, SpV0Info, }; use secp256k1::{Message, Parity, PublicKey, Scalar, Secp256k1, SecretKey, rand}; use silentpayments::receiving::{Label, Receiver}; -use silentpayments::utils::receiving::PublicTweakData; +use silentpayments::utils::receiving::{PublicTweakData, get_pubkey_from_input}; use silentpayments::utils::{NUMS_H, OutPoint as SpOutPoint}; use silentpayments::{Network, SpVersion, TransactionInputs, TransactionSharedSecret}; @@ -123,6 +127,89 @@ fn p2wpkh_input(secp: &Secp256k1, outpoint: OutPoint, secret: &S input } +/// Build a P2PKH `Input` funded to the compressed encoding of `secret`'s public key. +fn p2pkh_input( + secp: &Secp256k1, + outpoint: OutPoint, + secret: &SecretKey, +) -> Input { + let public = bitcoin::PublicKey::new(secret.public_key(secp)); + let mut input = Input::new(&outpoint); + input.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2pkh(&public.pubkey_hash()), + }, + ); + input + .bip32_derivations + .insert(public, (Fingerprint::default(), DerivationPath::default())); + input +} + +/// Build a P2SH-P2WPKH `Input`: the funding script commits to a P2WPKH redeem script for `secret`. +fn p2sh_p2wpkh_input( + secp: &Secp256k1, + outpoint: OutPoint, + secret: &SecretKey, +) -> Input { + let redeem_script = p2wpkh_script(secp, secret); + let mut input = Input::new(&outpoint); + input.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2sh(&redeem_script.script_hash()), + }, + ); + input.bip32_derivations.insert( + bitcoin::PublicKey::new(secret.public_key(secp)), + (Fingerprint::default(), DerivationPath::default()), + ); + input.redeem_script = Some(redeem_script); + input +} + +/// Build a P2PKH `Input` funded to the *uncompressed* encoding of `secret`'s public key, with +/// that uncompressed key in `bip32_derivations`. +fn p2pkh_uncompressed_input( + secp: &Secp256k1, + outpoint: OutPoint, + secret: &SecretKey, +) -> Input { + let public = bitcoin::PublicKey::new_uncompressed(secret.public_key(secp)); + let mut input = Input::new(&outpoint); + input.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2pkh(&public.pubkey_hash()), + }, + ); + input + .bip32_derivations + .insert(public, (Fingerprint::default(), DerivationPath::default())); + input +} + +/// A `scriptSig` spending [`p2pkh_uncompressed_input`]: a placeholder signature and the +/// uncompressed key. BIP-352 key extraction does not check the signature. +fn p2pkh_uncompressed_script_sig( + secp: &Secp256k1, + secret: &SecretKey, +) -> ScriptBuf { + ScriptBuf::builder() + .push_slice([0u8; 71]) + .push_key(&bitcoin::PublicKey::new_uncompressed( + secret.public_key(secp), + )) + .into_script() +} + fn outpoint(vout: u32) -> OutPoint { OutPoint::new( Txid::from_raw_hash(bitcoin::hashes::sha256d::Hash::all_zeros()), @@ -175,19 +262,22 @@ fn sp_p2tr_input( /// Sign input 0 as a BIP-376 silent payment input and write the signature. fn sign_sp_input(psbt: Psbt, spend_sk: &SecretKey, secp: &Secp256k1) -> Psbt { let mut signer = Signer::new(psbt).unwrap(); - let sigs = signer.session(|mut session| { - let inputs = session.signable_inputs().unwrap(); - vec![session - .get_silent_payment_sigs(&inputs, 0, spend_sk, secp) - .unwrap()] - }); + let verifier = SpOutputVerifier { secp }; + let sigs = signer + .session(&verifier, &[0], |mut session| { + let inputs = session.signable_inputs().unwrap(); + vec![session + .get_silent_payment_sigs(&inputs, 0, spend_sk, secp) + .unwrap()] + }) + .unwrap(); signer.apply(sigs).unwrap() } /// Rebuild the sender-side `TransactionInputs` exactly as `compute_sp_outputs` does. fn transaction_inputs_for(psbt: &Psbt) -> TransactionInputs { let mut inputs = TransactionInputs::with_capacity(psbt.global.input_count); - for input in psbt.inputs.iter() { + for (vin, input) in psbt.inputs.iter().enumerate() { let outpoint = SpOutPoint::from_txid_and_vout( &input.previous_txid.to_string(), input.spent_output_index, @@ -198,7 +288,7 @@ fn transaction_inputs_for(psbt: &Psbt) -> TransactionInputs { .unwrap() .script_pubkey .to_bytes(); - let pubkey = extract_eligible_input_pubkey(input).unwrap(); + let pubkey = extract_eligible_input_pubkey(input, vin).unwrap(); inputs.push(outpoint, spk, pubkey); } inputs @@ -214,7 +304,19 @@ fn assert_receiver_scan_finds_outputs( spend_pk: &PublicKey, ) { let inputs = transaction_inputs_for(psbt); - let tweak_data = PublicTweakData::new(secp, &inputs).unwrap(); + assert_receiver_scan_finds_outputs_from(secp, psbt, &inputs, scan_sk, spend_pk); +} + +/// Like [`assert_receiver_scan_finds_outputs`], with the receiver's input set supplied by the +/// caller instead of rebuilt from the PSBT fields the signer reads. +fn assert_receiver_scan_finds_outputs_from( + secp: &Secp256k1, + psbt: &Psbt, + inputs: &TransactionInputs, + scan_sk: &SecretKey, + spend_pk: &PublicKey, +) { + let tweak_data = PublicTweakData::new(secp, inputs).unwrap(); let shared_secret = TransactionSharedSecret::new_from_public_tweak_data(secp, &tweak_data, scan_sk).unwrap(); let receiver = Receiver::new( @@ -494,7 +596,7 @@ fn test_extract_p2wpkh_with_derivation_returns_pubkey() { (Fingerprint::default(), DerivationPath::default()), ); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert_eq!(result, Some(public)); } @@ -514,7 +616,7 @@ fn test_extract_p2wpkh_missing_derivation_returns_none() { }, ); // Deliberately omit bip32_derivations. - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert!( result.is_none(), "must return None when bip32_derivations is absent for a P2WPKH input" @@ -538,7 +640,7 @@ fn test_extract_p2tr_nums_h_internal_key_returns_none() { input.tap_internal_key = Some(nums); input.tap_merkle_root = Some(merkle_root); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert!( result.is_none(), "a NUMS_H script-path output must be non-contributing" @@ -557,7 +659,7 @@ fn test_extract_non_eligible_script_returns_none() { }, ); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert!(result.is_none()); } @@ -580,17 +682,17 @@ fn test_extract_p2sh_non_wpkh_redeem_returns_none() { ); input.redeem_script = Some(non_wpkh_redeem); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert!( result.is_none(), "P2SH with non-P2WPKH redeem must be ineligible" ); } -/// P2SH input with no redeem script set → must return `Ok(None)` (field not -/// populated yet). +/// P2SH input with no redeem script set → must error: it may be P2SH-P2WPKH, which the +/// receiver counts once it reads the redeem script from the final scriptSig. #[test] -fn test_extract_p2sh_missing_redeem_script_returns_none() { +fn test_extract_p2sh_missing_redeem_script_errors() { let secp = secp(); let secret = sk(1); let p2wpkh = p2wpkh_script(&secp, &secret); @@ -606,8 +708,37 @@ fn test_extract_p2sh_missing_redeem_script_returns_none() { ); // redeem_script intentionally absent. - let result = extract_eligible_input_pubkey(&input).unwrap(); - assert!(result.is_none()); + let result = extract_eligible_input_pubkey(&input, 3); + assert!( + matches!(result, Err(SpSignerError::MissingRedeemScript { vin: 3 })), + "got {result:?}" + ); +} + +/// The funding script is P2SH-P2WPKH, but the declared redeem script is something else and is not +/// P2WPKH. Without a hash check this input is skipped; the receiver spends the real redeem script +/// and counts the key. +#[test] +fn test_extract_p2sh_mismatched_redeem_script_errors() { + let secp = secp(); + let secret = sk(1); + let p2sh_script = ScriptBuf::new_p2sh(&p2wpkh_script(&secp, &secret).script_hash()); + + let mut input = Input::new(&outpoint(0)); + set_verified_funding_utxo( + &mut input, + TxOut { + value: Amount::from_sat(1_000), + script_pubkey: p2sh_script, + }, + ); + input.redeem_script = Some(p2tr_script(&secp, &sk(2))); + + let result = extract_eligible_input_pubkey(&input, 2); + assert!( + matches!(result, Err(SpSignerError::RedeemScriptMismatch { vin: 2 })), + "got {result:?}" + ); } #[test] @@ -668,7 +799,7 @@ fn test_extract_p2tr_sp_tweak_reads_output_key_from_prevout() { (Fingerprint::default(), DerivationPath::default()), ); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert_eq!(result, Some(xonly.public_key(Parity::Even))); } @@ -690,7 +821,7 @@ fn test_extract_p2tr_sp_tweak_without_derivation_map() { }); input.sp_tweak = Some(sk(2).secret_bytes()); - let result = extract_eligible_input_pubkey(&input).unwrap(); + let result = extract_eligible_input_pubkey(&input, 0).unwrap(); assert_eq!(result, Some(xonly.public_key(Parity::Even))); } @@ -950,3 +1081,503 @@ fn test_invalid_global_share_falls_back_to_partials() { "fallback to verified partials must recover the same scripts" ); } + +// ── 8. Signer/receiver disagreement ────────────────────────────────────────── + +/// BIP-352 only takes compressed keys from P2PKH inputs. A P2PKH output committing to an +/// uncompressed key does not contribute to the ECDH, so the signer must not return a key for it. +#[test] +fn test_extract_p2pkh_uncompressed_key_is_not_contributing() { + let secp = secp(); + let secret = sk(1); + let input = p2pkh_uncompressed_input(&secp, outpoint(0), &secret); + + assert_eq!( + extract_eligible_input_pubkey(&input, 0).unwrap(), + None, + "an uncompressed P2PKH key must not be added to the input key sum" + ); +} + +/// Alice spends a P2WPKH input and Bob an uncompressed P2PKH input; each adds a partial share +/// for their own input. The receiver reads Bob's key from his finalized `scriptSig` and skips it, +/// so the outputs committed before signing must be derived from Alice's key alone. +#[test] +fn test_uncompressed_p2pkh_cosigner_receiver_can_scan() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let bob_keys = bitcoin::PrivateKey::new_uncompressed(bob_sk, bitcoin::NetworkKind::Test); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + + let base = { + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &alice_sk); + psbt.inputs[1] = p2pkh_uncompressed_input(&secp, outpoint(1), &bob_sk); + psbt + }; + + let mut psbt = base.clone(); + psbt.add_ecdh_shares(&secp, &mut rng(), &alice_sk, ShareMode::Partial) + .unwrap(); + let mut psbt_bob = base; + // Bob's input does not contribute, so an uncompressed key yields no share. + let _ = psbt_bob.add_ecdh_shares(&secp, &mut rng(), &bob_keys, ShareMode::Partial); + psbt.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); + psbt.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); + + psbt.commit_sp_outputs(&secp).unwrap(); + + let mut receiver_inputs = TransactionInputs::with_capacity(2); + let alice = &psbt.inputs[0]; + receiver_inputs.push( + SpOutPoint::from_txid_and_vout(&alice.previous_txid.to_string(), alice.spent_output_index) + .unwrap(), + p2wpkh_script(&secp, &alice_sk).to_bytes(), + Some(alice_sk.public_key(&secp)), + ); + let bob = &psbt.inputs[1]; + let bob_spk = bob.witness_utxo.as_ref().unwrap().script_pubkey.clone(); + let bob_key = get_pubkey_from_input( + p2pkh_uncompressed_script_sig(&secp, &bob_sk).as_bytes(), + &[], + bob_spk.as_bytes(), + ) + .unwrap(); + assert_eq!(bob_key, None, "receiver skips an uncompressed P2PKH key"); + receiver_inputs.push( + SpOutPoint::from_txid_and_vout(&bob.previous_txid.to_string(), bob.spent_output_index) + .unwrap(), + bob_spk.to_bytes(), + bob_key, + ); + + assert_receiver_scan_finds_outputs_from(&secp, &psbt, &receiver_inputs, &scan_sk, &spend_pk); +} + +/// Bob's input is P2SH-P2WPKH but he leaves out `redeem_script` and adds no share. The receiver +/// will read the redeem script from his final scriptSig and count his key, so deriving the outputs +/// from Alice's share alone must fail. +#[test] +fn test_derive_rejects_p2sh_cosigner_without_redeem_script() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &alice_sk); + let mut bob = Input::new(&outpoint(1)); + bob.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut bob, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2sh(&p2wpkh_script(&secp, &bob_sk).script_hash()), + }, + ); + psbt.inputs[1] = bob; + + psbt.add_ecdh_shares(&secp, &mut rng(), &alice_sk, ShareMode::Partial) + .unwrap(); + + let result = psbt.derive_sp_output_scripts(&secp); + assert!( + matches!(result, Err(SpSignerError::MissingRedeemScript { vin: 1 })), + "got {result:?}" + ); +} + +/// Same as a missing redeem script, except Bob declares a redeem script that does not hash to his +/// P2SH output and is not P2WPKH. Deriving from Alice's share alone must fail. +#[test] +fn test_derive_rejects_p2sh_cosigner_with_mismatched_redeem_script() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &alice_sk); + let mut bob = Input::new(&outpoint(1)); + bob.sequence = Some(Sequence::MAX); + set_verified_funding_utxo( + &mut bob, + TxOut { + value: Amount::from_sat(20_000), + script_pubkey: ScriptBuf::new_p2sh(&p2wpkh_script(&secp, &bob_sk).script_hash()), + }, + ); + bob.redeem_script = Some(p2tr_script(&secp, &sk(5))); + psbt.inputs[1] = bob; + + psbt.add_ecdh_shares(&secp, &mut rng(), &alice_sk, ShareMode::Partial) + .unwrap(); + + let result = psbt.derive_sp_output_scripts(&secp); + assert!( + matches!(result, Err(SpSignerError::RedeemScriptMismatch { vin: 1 })), + "got {result:?}" + ); +} + +/// Alice and Bob each add a partial share for their own input, and the outputs are committed. +fn committed_two_party_psbt( + secp: &Secp256k1, + alice: (Input, &SecretKey), + bob: (Input, &SecretKey), +) -> Psbt { + let scan_pk = pk(secp, 2); + let spend_pk = pk(secp, 3); + let mut base = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + base.inputs[0] = alice.0; + base.inputs[1] = bob.0; + + let mut psbt = base.clone(); + psbt.add_ecdh_shares(secp, &mut rng(), alice.1, ShareMode::Partial) + .unwrap(); + let mut psbt_bob = base; + psbt_bob + .add_ecdh_shares(secp, &mut rng(), bob.1, ShareMode::Partial) + .unwrap(); + psbt.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); + psbt.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); + psbt.commit_sp_outputs(secp).unwrap(); + psbt +} + +/// Bob's P2WPKH funding output is only given as `witness_utxo`. Alice signs a SegWit v0 input, +/// whose signature does not commit to Bob's script, so she must refuse. Bob vouches for his own +/// input, so signing both is accepted. +#[test] +fn test_verify_before_signing_rejects_unverified_prevout() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let mut bob = p2wpkh_input(&secp, outpoint(1), &bob_sk); + bob.non_witness_utxo = None; + let psbt = committed_two_party_psbt( + &secp, + (p2wpkh_input(&secp, outpoint(0), &alice_sk), &alice_sk), + (bob, &bob_sk), + ); + + let result = psbt.verify_before_signing(&secp, &[0]); + assert!( + matches!(result, Err(SpSignerError::UnverifiedPrevout { vin: 1 })), + "got {result:?}" + ); + psbt.verify_before_signing(&secp, &[0, 1]).unwrap(); +} + +/// Same unverified funding output for Bob, but Alice signs a P2TR input: her signature commits to +/// every prevout script, so a misreported script only invalidates it. +#[test] +fn test_verify_before_signing_accepts_unverified_prevout_when_signing_p2tr() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let mut bob = p2wpkh_input(&secp, outpoint(1), &bob_sk); + bob.non_witness_utxo = None; + let psbt = committed_two_party_psbt( + &secp, + ( + sp_p2tr_input(&secp, outpoint(0), &alice_sk, sk(7).secret_bytes()), + &alice_sk, + ), + (bob, &bob_sk), + ); + + psbt.verify_before_signing(&secp, &[0]).unwrap(); +} + +/// A PSBT that comes back with a silent payment output script that does not follow from the +/// shares must not be signed. +#[test] +fn test_verify_before_signing_rejects_tampered_output_script() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + psbt.verify_before_signing(&secp, &[0]).unwrap(); + + psbt.outputs[0].script_pubkey = p2tr_script(&secp, &sk(9)); + let result = psbt.verify_before_signing(&secp, &[0]); + assert!( + matches!( + result, + Err(SpSignerError::OutputScriptMismatch { index: 0 }) + ), + "got {result:?}" + ); +} + +/// A compressed P2PKH key matches its script and is what the receiver extracts from the scriptSig. +#[test] +fn test_compressed_p2pkh_contributes_and_receiver_can_scan() { + let secp = secp(); + let spend_sk = sk(1); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + let input = p2pkh_input(&secp, outpoint(0), &spend_sk); + + assert_eq!( + extract_eligible_input_pubkey(&input, 0).unwrap(), + Some(spend_sk.public_key(&secp)) + ); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = input; + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + + let spk = psbt.inputs[0] + .witness_utxo + .as_ref() + .unwrap() + .script_pubkey + .clone(); + let script_sig = ScriptBuf::builder() + .push_slice([0u8; 71]) + .push_key(&bitcoin::PublicKey::new(spend_sk.public_key(&secp))) + .into_script(); + let pubkey = get_pubkey_from_input(script_sig.as_bytes(), &[], spk.as_bytes()).unwrap(); + assert_eq!(pubkey, Some(spend_sk.public_key(&secp))); + + let mut inputs = TransactionInputs::with_capacity(1); + inputs + .push( + SpOutPoint::from_txid_and_vout( + &psbt.inputs[0].previous_txid.to_string(), + psbt.inputs[0].spent_output_index, + ) + .unwrap(), + spk.to_bytes(), + pubkey, + ); + assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); +} + +/// A P2SH-P2WPKH input contributes its compressed key, and the receiver recovers the same key +/// from the redeem script and witness. +#[test] +fn test_p2sh_p2wpkh_contributes_and_receiver_can_scan() { + let secp = secp(); + let spend_sk = sk(1); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + let input = p2sh_p2wpkh_input(&secp, outpoint(0), &spend_sk); + + assert_eq!( + extract_eligible_input_pubkey(&input, 0).unwrap(), + Some(spend_sk.public_key(&secp)) + ); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = input; + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + + let redeem = psbt.inputs[0].redeem_script.clone().unwrap(); + let spk = psbt.inputs[0] + .witness_utxo + .as_ref() + .unwrap() + .script_pubkey + .clone(); + let script_sig = ScriptBuf::builder() + .push_slice(<&bitcoin::script::PushBytes>::try_from(redeem.as_bytes()).unwrap()) + .into_script(); + let witness = vec![ + vec![0u8; 72], + spend_sk.public_key(&secp).serialize().to_vec(), + ]; + let pubkey = get_pubkey_from_input(script_sig.as_bytes(), &witness, spk.as_bytes()).unwrap(); + assert_eq!(pubkey, Some(spend_sk.public_key(&secp))); + + let mut inputs = TransactionInputs::with_capacity(1); + inputs + .push( + SpOutPoint::from_txid_and_vout( + &psbt.inputs[0].previous_txid.to_string(), + psbt.inputs[0].spent_output_index, + ) + .unwrap(), + spk.to_bytes(), + pubkey, + ); + assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); +} + +/// The signer owns both inputs. Global mode must leave the uncompressed P2PKH key out of the sum, +/// which is what the receiver does when it reads that scriptSig. +#[test] +fn test_global_share_skips_owned_uncompressed_p2pkh() { + let secp = secp(); + let spend_sk = sk(1); + let uncompressed_sk = sk(4); + let scan_sk = sk(2); + let scan_pk = scan_sk.public_key(&secp); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt( + vec![sp_output(&scan_pk, &spend_pk)], + vec![outpoint(0), outpoint(1)], + ); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + psbt.inputs[1] = p2pkh_uncompressed_input(&secp, outpoint(1), &uncompressed_sk); + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + + let mut inputs = TransactionInputs::with_capacity(2); + let eligible = &psbt.inputs[0]; + inputs + .push( + SpOutPoint::from_txid_and_vout( + &eligible.previous_txid.to_string(), + eligible.spent_output_index, + ) + .unwrap(), + p2wpkh_script(&secp, &spend_sk).to_bytes(), + Some(spend_sk.public_key(&secp)), + ); + let skipped = &psbt.inputs[1]; + let skipped_spk = skipped + .witness_utxo + .as_ref() + .unwrap() + .script_pubkey + .clone(); + let skipped_key = get_pubkey_from_input( + p2pkh_uncompressed_script_sig(&secp, &uncompressed_sk).as_bytes(), + &[], + skipped_spk.as_bytes(), + ) + .unwrap(); + assert_eq!(skipped_key, None); + inputs + .push( + SpOutPoint::from_txid_and_vout( + &skipped.previous_txid.to_string(), + skipped.spent_output_index, + ) + .unwrap(), + skipped_spk.to_bytes(), + skipped_key, + ); + assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); +} + +/// An uncompressed P2PKH input is the only one. Global mode has no key to sum. +#[test] +fn test_global_share_rejects_only_uncompressed_p2pkh() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2pkh_uncompressed_input(&secp, outpoint(0), &spend_sk); + + let result = psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global); + assert!(result.is_err(), "got {result:?}"); + assert!(psbt.global.sp_ecdh_shares.is_empty()); +} + +/// An empty silent-payment script has not been derived, so it must not be signed. +#[test] +fn test_verify_before_signing_rejects_empty_output_script() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + psbt.outputs[0].script_pubkey = ScriptBuf::new(); + + let result = psbt.verify_before_signing(&secp, &[0]); + assert!( + matches!( + result, + Err(SpSignerError::OutputScriptMismatch { index: 0 }) + ), + "got {result:?}" + ); +} + +/// A signed-input index past the end of the PSBT is rejected. +#[test] +fn test_verify_before_signing_rejects_out_of_range_index() { + let secp = secp(); + let spend_sk = sk(1); + let scan_pk = pk(&secp, 2); + let spend_pk = pk(&secp, 3); + + let mut psbt = new_psbt(vec![sp_output(&scan_pk, &spend_pk)], vec![outpoint(0)]); + psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); + psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) + .unwrap(); + psbt.commit_sp_outputs(&secp).unwrap(); + + let result = psbt.verify_before_signing(&secp, &[9]); + assert!( + matches!(result, Err(SpSignerError::MalformedInput { vin: 9, .. })), + "got {result:?}" + ); +} + +/// The session was opened for input 0 only. Minting a signable input 1 must fail. +#[test] +fn test_session_rejects_signing_outside_declared_inputs() { + let secp = secp(); + let alice_sk = sk(1); + let bob_sk = sk(4); + let psbt = committed_two_party_psbt( + &secp, + (p2wpkh_input(&secp, outpoint(0), &alice_sk), &alice_sk), + (p2wpkh_input(&secp, outpoint(1), &bob_sk), &bob_sk), + ); + let mut signer = Signer::new(psbt).unwrap(); + let verifier = SpOutputVerifier { secp: &secp }; + let result = signer.session(&verifier, &[0], |session| { + session.signable_input(1).map(|_| ()) + }); + assert!( + matches!( + result, + Ok(Err(SignError::NotInSignedInputs { index: 1 })) + ), + "got {result:?}" + ); +} diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index a6e98f3a..97ab547e 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -10,7 +10,7 @@ use bitcoin::{ Amount, CompressedPublicKey, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxOut, }; use psbt::extractor::SpExtractorExt as _; -use psbt::signer::{ShareMode, SpSignerExt as _}; +use psbt::signer::{ShareMode, SpOutputVerifier, SpSignerExt as _}; use psbt_v2::{ Constructor, Extractor, Finalizer, Input, Modifiable, Output, Psbt, Signer, SpV0Info, }; @@ -249,6 +249,10 @@ impl SpClient { /// Adds a global ECDH share (this wallet owns every input) when none is /// present, then commits the scripts. A PSBT with no silent-payment outputs /// is returned unchanged. Requires the spend secret when shares are missing. + /// + /// When every silent-payment output already has a script, the scripts are + /// checked against the shares instead of being trusted. This wallet signs + /// every input, so that is the set passed to the check. pub fn commit_sp_outputs(&self, mut psbt: Psbt) -> Result { let mut pending = false; let mut committed = false; @@ -268,6 +272,11 @@ impl SpClient { )); } if !pending { + if committed { + let secp = Secp256k1::new(); + let signed_inputs: Vec = (0..psbt.inputs.len()).collect(); + psbt.verify_before_signing(&secp, &signed_inputs)?; + } return Ok(psbt); } @@ -297,24 +306,27 @@ impl SpClient { let mut signer = Signer::new(psbt)?; // Every wallet input is a BIP-376 spend. The default Taproot sighash commits to // every prevout, so the inputs have to be validated as one set. - let sigs = signer.session(|mut session| -> Result> { - let inputs = session.signable_inputs().map_err(|errors| { - Error::msg( - errors - .iter() - .map(|(index, error)| format!("input {index}: {error}")) - .collect::>() - .join(", "), - ) - })?; - (0..input_count) - .map(|index| { - session - .get_silent_payment_sigs(&inputs, index, &spend_sk, &secp) - .map_err(Error::from) - }) - .collect() - })?; + let signed_inputs: Vec = (0..input_count).collect(); + let verifier = SpOutputVerifier { secp: &secp }; + let sigs = signer + .session(&verifier, &signed_inputs, |mut session| -> Result> { + let inputs = session.signable_inputs().map_err(|errors| { + Error::msg( + errors + .iter() + .map(|(index, error)| format!("input {index}: {error}")) + .collect::>() + .join(", "), + ) + })?; + (0..input_count) + .map(|index| { + session + .get_silent_payment_sigs(&inputs, index, &spend_sk, &secp) + .map_err(Error::from) + }) + .collect() + })??; Ok(signer.apply(sigs)?) } @@ -606,4 +618,59 @@ mod tests { assert_eq!(tx.output.len(), 1); assert!(tx.input.iter().all(|input| !input.witness.is_empty())); } + + #[test] + fn commit_sp_outputs_rejects_a_swapped_script() { + let client = test_client(); + let utxos = wallet_utxos(&[100_000, 200_000]); + let recipients = vec![payment_recipient(50_000)]; + let selections = + propose_coin_selections(&utxos, &recipients, test_fee_rate()).expect("selection"); + let selection = selections + .into_iter() + .find(|s| s.change() > Amount::ZERO) + .expect("a selection with change"); + let psbt = client + .create_transaction_from_proposal(&utxos, recipients, &selection, Network::Regtest) + .expect("transaction"); + let mut psbt = client.commit_sp_outputs(psbt).expect("commit"); + let recommitted = client + .commit_sp_outputs(psbt.clone()) + .expect("an already committed PSBT must still verify"); + assert_eq!( + recommitted + .outputs + .iter() + .map(|output| output.script_pubkey.clone()) + .collect::>(), + psbt.outputs + .iter() + .map(|output| output.script_pubkey.clone()) + .collect::>() + ); + + let change_vout = psbt + .outputs + .iter() + .position(|o| o.sp_v0_info.is_some()) + .expect("change output"); + let secp = Secp256k1::new(); + let sk = SecretKey::from_slice(&[0x44; 32]).expect("valid test key"); + let (xonly, _) = sk.x_only_public_key(&secp); + psbt.outputs[change_vout].script_pubkey = + ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()); + + let err = client + .commit_sp_outputs(psbt.clone()) + .expect_err("a swapped silent payment script must be rejected"); + assert!(err.to_string().contains("does not match")); + + let err = client + .sign_inputs(psbt) + .expect_err("signing a swapped silent payment script must be rejected"); + assert!( + err.chain().any(|cause| cause.to_string().contains("does not match")), + "{err:#}" + ); + } } From 37bae1691d4b0668a68d09de837b96bc0cbb0f89 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 4 Nov 2026 16:15:36 +0100 Subject: [PATCH 10/13] build(psbt): bump psbt-v2 to e7c2264c input_count and spent_output_index are no longer plain integers, so the BIP-352 input set converts them. --- Cargo.toml | 2 +- psbt/src/extractor.rs | 4 +- psbt/src/signer.rs | 4 +- psbt/tests/signer.rs | 114 ++++++++++++++++++------------------------ 4 files changed, 55 insertions(+), 69 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 97b366d5..fe0972ed 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,7 +38,7 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } -psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "2fb5abceaee36d3a72885a3fe21a2f630220f000", features = ["silent-payments", "miniscript"] } +psbt-v2 = { git = "https://gitea.bitcoin.ninja/sosthene/rust-psbt.git", rev = "e7c2264c50d0f5c0b82c87af7884fb1f9296b971", features = ["silent-payments", "miniscript"] } # DLEQ (BIP-374) backend decision (2026-09): # We use rust-dleq's pure-Rust `standalone` backend (the default in `silentpayments` # and `psbt`), pinned to this fork. It is verified against the official BIP-374 diff --git a/psbt/src/extractor.rs b/psbt/src/extractor.rs index e8f93b33..e3741d02 100644 --- a/psbt/src/extractor.rs +++ b/psbt/src/extractor.rs @@ -103,11 +103,11 @@ impl SpExtractorExt for Psbt { return Ok(()); } - let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count); + let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count.into()); for (vin, input) in self.inputs.iter().enumerate() { let outpoint = SpOutPoint::from_txid_and_vout( &input.previous_txid.to_string(), - input.spent_output_index, + input.spent_output_index.into(), ) .map_err(SpSignerError::from)?; let spk = &funding_output(input) diff --git a/psbt/src/signer.rs b/psbt/src/signer.rs index fa4f5a94..7cf54fc3 100644 --- a/psbt/src/signer.rs +++ b/psbt/src/signer.rs @@ -444,11 +444,11 @@ impl SpSignerExt for Psbt { } // The BIP-352 input set, exactly as the receiver rebuilds it. - let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count); + let mut transaction_inputs = TransactionInputs::with_capacity(self.global.input_count.into()); for (vin, input) in self.inputs.iter().enumerate() { let outpoint = SpOutPoint::from_txid_and_vout( &input.previous_txid.to_string(), - input.spent_output_index, + input.spent_output_index.into(), )?; let spk = funding_output(input)?.script_pubkey.to_bytes(); let pubkey = extract_eligible_input_pubkey(input, vin)?; diff --git a/psbt/tests/signer.rs b/psbt/tests/signer.rs index d27a88ac..2d167873 100644 --- a/psbt/tests/signer.rs +++ b/psbt/tests/signer.rs @@ -87,7 +87,7 @@ fn sp_output(scan: &PublicKey, spend: &PublicKey) -> Output { /// for non-P2TR spends, so both UTXO forms are set and kept consistent. /// The txid of the `OutPoint` passed to [`Input::new`] is not preserved. fn set_verified_funding_utxo(input: &mut Input, txout: TxOut) { - let vout = input.spent_output_index as usize; + let vout: usize = input.spent_output_index.into(); let mut output = vec![ TxOut { value: Amount::ZERO, @@ -128,11 +128,7 @@ fn p2wpkh_input(secp: &Secp256k1, outpoint: OutPoint, secret: &S } /// Build a P2PKH `Input` funded to the compressed encoding of `secret`'s public key. -fn p2pkh_input( - secp: &Secp256k1, - outpoint: OutPoint, - secret: &SecretKey, -) -> Input { +fn p2pkh_input(secp: &Secp256k1, outpoint: OutPoint, secret: &SecretKey) -> Input { let public = bitcoin::PublicKey::new(secret.public_key(secp)); let mut input = Input::new(&outpoint); input.sequence = Some(Sequence::MAX); @@ -266,9 +262,11 @@ fn sign_sp_input(psbt: Psbt, spend_sk: &SecretKey, secp: &Secp256k1 TransactionInputs { - let mut inputs = TransactionInputs::with_capacity(psbt.global.input_count); + let mut inputs = TransactionInputs::with_capacity(psbt.global.input_count.into()); for (vin, input) in psbt.inputs.iter().enumerate() { let outpoint = SpOutPoint::from_txid_and_vout( &input.previous_txid.to_string(), - input.spent_output_index, + input.spent_output_index.into(), ) .unwrap(); let spk = input @@ -869,7 +867,7 @@ fn test_sign_sp_inputs_produces_valid_taproot_sig() { .inputs .iter() .map(|i| bitcoin::TxIn { - previous_output: OutPoint::new(i.previous_txid, i.spent_output_index), + previous_output: OutPoint::new(i.previous_txid, i.spent_output_index.into()), script_sig: ScriptBuf::new(), sequence: i.sequence.unwrap_or(Sequence::MAX), witness: bitcoin::Witness::new(), @@ -1136,7 +1134,7 @@ fn test_uncompressed_p2pkh_cosigner_receiver_can_scan() { let mut receiver_inputs = TransactionInputs::with_capacity(2); let alice = &psbt.inputs[0]; receiver_inputs.push( - SpOutPoint::from_txid_and_vout(&alice.previous_txid.to_string(), alice.spent_output_index) + SpOutPoint::from_txid_and_vout(&alice.previous_txid.to_string(), alice.spent_output_index.into()) .unwrap(), p2wpkh_script(&secp, &alice_sk).to_bytes(), Some(alice_sk.public_key(&secp)), @@ -1151,7 +1149,7 @@ fn test_uncompressed_p2pkh_cosigner_receiver_can_scan() { .unwrap(); assert_eq!(bob_key, None, "receiver skips an uncompressed P2PKH key"); receiver_inputs.push( - SpOutPoint::from_txid_and_vout(&bob.previous_txid.to_string(), bob.spent_output_index) + SpOutPoint::from_txid_and_vout(&bob.previous_txid.to_string(), bob.spent_output_index.into()) .unwrap(), bob_spk.to_bytes(), bob_key, @@ -1369,16 +1367,15 @@ fn test_compressed_p2pkh_contributes_and_receiver_can_scan() { assert_eq!(pubkey, Some(spend_sk.public_key(&secp))); let mut inputs = TransactionInputs::with_capacity(1); - inputs - .push( - SpOutPoint::from_txid_and_vout( - &psbt.inputs[0].previous_txid.to_string(), - psbt.inputs[0].spent_output_index, - ) - .unwrap(), - spk.to_bytes(), - pubkey, - ); + inputs.push( + SpOutPoint::from_txid_and_vout( + &psbt.inputs[0].previous_txid.to_string(), + psbt.inputs[0].spent_output_index.into(), + ) + .unwrap(), + spk.to_bytes(), + pubkey, + ); assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); } @@ -1422,16 +1419,15 @@ fn test_p2sh_p2wpkh_contributes_and_receiver_can_scan() { assert_eq!(pubkey, Some(spend_sk.public_key(&secp))); let mut inputs = TransactionInputs::with_capacity(1); - inputs - .push( - SpOutPoint::from_txid_and_vout( - &psbt.inputs[0].previous_txid.to_string(), - psbt.inputs[0].spent_output_index, - ) - .unwrap(), - spk.to_bytes(), - pubkey, - ); + inputs.push( + SpOutPoint::from_txid_and_vout( + &psbt.inputs[0].previous_txid.to_string(), + psbt.inputs[0].spent_output_index.into(), + ) + .unwrap(), + spk.to_bytes(), + pubkey, + ); assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); } @@ -1458,23 +1454,17 @@ fn test_global_share_skips_owned_uncompressed_p2pkh() { let mut inputs = TransactionInputs::with_capacity(2); let eligible = &psbt.inputs[0]; - inputs - .push( - SpOutPoint::from_txid_and_vout( - &eligible.previous_txid.to_string(), - eligible.spent_output_index, - ) - .unwrap(), - p2wpkh_script(&secp, &spend_sk).to_bytes(), - Some(spend_sk.public_key(&secp)), - ); + inputs.push( + SpOutPoint::from_txid_and_vout( + &eligible.previous_txid.to_string(), + eligible.spent_output_index.into(), + ) + .unwrap(), + p2wpkh_script(&secp, &spend_sk).to_bytes(), + Some(spend_sk.public_key(&secp)), + ); let skipped = &psbt.inputs[1]; - let skipped_spk = skipped - .witness_utxo - .as_ref() - .unwrap() - .script_pubkey - .clone(); + let skipped_spk = skipped.witness_utxo.as_ref().unwrap().script_pubkey.clone(); let skipped_key = get_pubkey_from_input( p2pkh_uncompressed_script_sig(&secp, &uncompressed_sk).as_bytes(), &[], @@ -1482,16 +1472,15 @@ fn test_global_share_skips_owned_uncompressed_p2pkh() { ) .unwrap(); assert_eq!(skipped_key, None); - inputs - .push( - SpOutPoint::from_txid_and_vout( - &skipped.previous_txid.to_string(), - skipped.spent_output_index, - ) - .unwrap(), - skipped_spk.to_bytes(), - skipped_key, - ); + inputs.push( + SpOutPoint::from_txid_and_vout( + &skipped.previous_txid.to_string(), + skipped.spent_output_index.into(), + ) + .unwrap(), + skipped_spk.to_bytes(), + skipped_key, + ); assert_receiver_scan_finds_outputs_from(&secp, &psbt, &inputs, &scan_sk, &spend_pk); } @@ -1574,10 +1563,7 @@ fn test_session_rejects_signing_outside_declared_inputs() { session.signable_input(1).map(|_| ()) }); assert!( - matches!( - result, - Ok(Err(SignError::NotInSignedInputs { index: 1 })) - ), + matches!(result, Ok(Err(SignError::NotInSignedInputs { index: 1 }))), "got {result:?}" ); } From 6c4f9e5b79a1a51b6b26936b3bc049e72231571b Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 4 Nov 2026 16:16:21 +0100 Subject: [PATCH 11/13] refactor(psbt): drop the commit_sp_outputs wrapper Callers derive the scripts and commit them through the upstream Signer. The wrapper's lock-time and commit error variants go with it. --- psbt/src/signer.rs | 44 +-------------------------------- psbt/tests/bip375_vectors.rs | 15 ++++++----- psbt/tests/signer.rs | 31 ++++++++++++++--------- spdk-wallet/src/client/spend.rs | 6 +++-- 4 files changed, 33 insertions(+), 63 deletions(-) diff --git a/psbt/src/signer.rs b/psbt/src/signer.rs index 7cf54fc3..3b08916f 100644 --- a/psbt/src/signer.rs +++ b/psbt/src/signer.rs @@ -21,10 +21,7 @@ use std::fmt; use bitcoin::key::TweakedPublicKey; use bitcoin::{CompressedPublicKey, ScriptBuf, XOnlyPublicKey}; -use psbt_v2::{ - CommitSilentPaymentOutputsError, DetermineLockTimeError, FundingUtxoError, GetKey, Input, - KeyRequest, Psbt, SilentPaymentVerifier, Signer as UpstreamSigner, SpV0Info, -}; +use psbt_v2::{FundingUtxoError, GetKey, Input, KeyRequest, Psbt, SilentPaymentVerifier, SpV0Info}; use secp256k1::rand::{CryptoRng, RngCore}; use secp256k1::{Parity, PublicKey, Scalar, Secp256k1, SecretKey, Signing, Verification}; use silentpayments::sending::generate_recipient_pubkeys; @@ -87,10 +84,6 @@ pub enum SpSignerError { SilentPayments(silentpayments::Error), /// secp256k1 failure. Secp256k1(secp256k1::Error), - /// Upstream lock-time determination failed when constructing the commit signer. - DetermineLockTime(DetermineLockTimeError), - /// Upstream `commit_silent_payment_outputs` rejected the derived scripts. - CommitOutputs(CommitSilentPaymentOutputsError), /// A silent payment output script is empty or differs from the one derived from the /// verified ECDH shares. OutputScriptMismatch { index: usize }, @@ -148,8 +141,6 @@ impl fmt::Display for SpSignerError { ), E::SilentPayments(e) => write!(f, "silent payments error: {e}"), E::Secp256k1(e) => write!(f, "secp256k1 error: {e}"), - E::DetermineLockTime(e) => write!(f, "cannot determine lock time: {e}"), - E::CommitOutputs(e) => write!(f, "failed to commit silent payment outputs: {e}"), E::OutputScriptMismatch { index } => write!( f, "output {index}: silent payment script does not match the verified ECDH shares" @@ -192,18 +183,6 @@ impl From for SpSignerError { } } -impl From for SpSignerError { - fn from(value: DetermineLockTimeError) -> Self { - Self::DetermineLockTime(value) - } -} - -impl From for SpSignerError { - fn from(value: CommitSilentPaymentOutputsError) -> Self { - Self::CommitOutputs(value) - } -} - /// Who am I in this transaction? Explicit, not auto-detected. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ShareMode { @@ -258,13 +237,6 @@ pub trait SpSignerExt { where C: Signing + Verification; - /// Single-signer convenience: derive + commit in one step. The commit is - /// upstream's `commit_silent_payment_outputs`, which runs the BIP-375 signer - /// checks and clears the modifiable flags. `self` is left untouched on error. - fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> - where - C: Signing + Verification; - /// BIP-375 signer gate: checks that the silent payment output scripts can be signed. /// /// Must run on the exact PSBT passed to `Signer::new`. Upstream signing only checks that the @@ -461,20 +433,6 @@ impl SpSignerExt for Psbt { derive_sp_output_scripts_from_inputs(self, secp, &transaction_inputs) } - fn commit_sp_outputs(&mut self, secp: &Secp256k1) -> Result<(), SpSignerError> - where - C: Signing + Verification, - { - let scripts = self.derive_sp_output_scripts(secp)?; - // Upstream commit: refuses script mismatches, clears the modifiable flags - // (without clobbering SIGHASH_SINGLE) and runs the BIP-375 signer checks. - // Operate on a clone so `self` stays untouched on error. - let mut signer = UpstreamSigner::new(self.clone())?; - signer.commit_silent_payment_outputs(scripts)?; - *self = signer.psbt(); - Ok(()) - } - fn verify_before_signing( &self, secp: &Secp256k1, diff --git a/psbt/tests/bip375_vectors.rs b/psbt/tests/bip375_vectors.rs index a70d956f..bf96915a 100644 --- a/psbt/tests/bip375_vectors.rs +++ b/psbt/tests/bip375_vectors.rs @@ -9,7 +9,7 @@ use std::path::PathBuf; use bitcoin::base64::prelude::{BASE64_STANDARD, Engine as _}; use psbt::extractor::{SpExtractorError, SpExtractorExt}; use psbt::signer::SpSignerExt; -use psbt_v2::{Finalizer, Psbt, SilentPaymentState}; +use psbt_v2::{Finalizer, Psbt, Signer, SilentPaymentState}; use secp256k1::Secp256k1; use serde::Deserialize; @@ -67,11 +67,14 @@ fn parse_psbt(base64: &str) -> Result { fn derive_outputs(psbt: &Psbt) -> Result { let secp = Secp256k1::new(); - let mut derived = psbt.clone(); - derived - .commit_sp_outputs(&secp) - .map_err(|e| format!("commit_sp_outputs failed: {e}"))?; - Ok(derived) + let scripts = psbt + .derive_sp_output_scripts(&secp) + .map_err(|e| format!("derive_sp_output_scripts failed: {e}"))?; + let mut signer = Signer::new(psbt.clone()).map_err(|e| format!("Signer::new failed: {e}"))?; + signer + .commit_silent_payment_outputs(scripts) + .map_err(|e| format!("commit_silent_payment_outputs failed: {e}"))?; + Ok(signer.psbt()) } fn has_unsigned_inputs(psbt: &Psbt) -> bool { diff --git a/psbt/tests/signer.rs b/psbt/tests/signer.rs index 2d167873..5c1c84b9 100644 --- a/psbt/tests/signer.rs +++ b/psbt/tests/signer.rs @@ -48,6 +48,13 @@ fn rng() -> rand::rngs::ThreadRng { rand::thread_rng() } +fn commit_derived_outputs(psbt: &mut Psbt, secp: &Secp256k1) { + let scripts = psbt.derive_sp_output_scripts(secp).unwrap(); + let mut signer = Signer::new(psbt.clone()).unwrap(); + signer.commit_silent_payment_outputs(scripts).unwrap(); + *psbt = signer.psbt(); +} + fn sk(byte: u8) -> SecretKey { SecretKey::from_slice(&[byte; 32]).unwrap() } @@ -373,7 +380,7 @@ fn test_single_signer_e2e() { let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); assert_eq!(scripts.len(), 1); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let sp_out = psbt .outputs @@ -563,7 +570,7 @@ fn test_single_signer_ignores_non_eligible_input() { .unwrap(); let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); assert_eq!(scripts.len(), 1); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let sp_out = psbt .outputs @@ -912,7 +919,7 @@ fn test_single_signer_sp_input_receiver_can_scan() { .unwrap(); let scripts = psbt.derive_sp_output_scripts(&secp).unwrap(); assert_eq!(scripts.len(), 1); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); assert_receiver_scan_finds_outputs(&secp, &psbt, &scan_sk, &spend_pk); } @@ -1003,7 +1010,7 @@ fn test_multi_signer_two_parties_receiver_can_scan() { psbt_alice.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); psbt_alice.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); - psbt_alice.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt_alice, &secp); assert_receiver_scan_finds_outputs(&secp, &psbt_alice, &scan_sk, &spend_pk); } @@ -1129,7 +1136,7 @@ fn test_uncompressed_p2pkh_cosigner_receiver_can_scan() { psbt.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); psbt.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let mut receiver_inputs = TransactionInputs::with_capacity(2); let alice = &psbt.inputs[0]; @@ -1256,7 +1263,7 @@ fn committed_two_party_psbt( .unwrap(); psbt.inputs[1].sp_ecdh_shares = psbt_bob.inputs[1].sp_ecdh_shares.clone(); psbt.inputs[1].sp_dleq_proofs = psbt_bob.inputs[1].sp_dleq_proofs.clone(); - psbt.commit_sp_outputs(secp).unwrap(); + commit_derived_outputs(&mut psbt, secp); psbt } @@ -1318,7 +1325,7 @@ fn test_verify_before_signing_rejects_tampered_output_script() { psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); psbt.verify_before_signing(&secp, &[0]).unwrap(); psbt.outputs[0].script_pubkey = p2tr_script(&secp, &sk(9)); @@ -1351,7 +1358,7 @@ fn test_compressed_p2pkh_contributes_and_receiver_can_scan() { psbt.inputs[0] = input; psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let spk = psbt.inputs[0] .witness_utxo @@ -1399,7 +1406,7 @@ fn test_p2sh_p2wpkh_contributes_and_receiver_can_scan() { psbt.inputs[0] = input; psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let redeem = psbt.inputs[0].redeem_script.clone().unwrap(); let spk = psbt.inputs[0] @@ -1450,7 +1457,7 @@ fn test_global_share_skips_owned_uncompressed_p2pkh() { psbt.inputs[1] = p2pkh_uncompressed_input(&secp, outpoint(1), &uncompressed_sk); psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let mut inputs = TransactionInputs::with_capacity(2); let eligible = &psbt.inputs[0]; @@ -1512,7 +1519,7 @@ fn test_verify_before_signing_rejects_empty_output_script() { psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); psbt.outputs[0].script_pubkey = ScriptBuf::new(); let result = psbt.verify_before_signing(&secp, &[0]); @@ -1537,7 +1544,7 @@ fn test_verify_before_signing_rejects_out_of_range_index() { psbt.inputs[0] = p2wpkh_input(&secp, outpoint(0), &spend_sk); psbt.add_ecdh_shares(&secp, &mut rng(), &spend_sk, ShareMode::Global) .unwrap(); - psbt.commit_sp_outputs(&secp).unwrap(); + commit_derived_outputs(&mut psbt, &secp); let result = psbt.verify_before_signing(&secp, &[9]); assert!( diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index 97ab547e..3f269ebb 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -291,8 +291,10 @@ impl SpClient { let mut rng = OsRng; psbt.add_ecdh_shares(&secp, &mut rng, &spend_sk, ShareMode::Global)?; } - psbt.commit_sp_outputs(&secp)?; - Ok(psbt) + let scripts = psbt.derive_sp_output_scripts(&secp)?; + let mut signer = Signer::new(psbt)?; + signer.commit_silent_payment_outputs(scripts)?; + Ok(signer.psbt()) } /// Signs every input this wallet can sign. Does not finalize witnesses. From 513da701113e25613fd2b218c4cede2ec54bc041 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 4 Nov 2026 16:17:17 +0100 Subject: [PATCH 12/13] refactor(spdk-wallet): verify committed scripts separately from commit commit_sp_outputs now refuses a PSBT whose silent-payment scripts are already set. Checking those scripts is verify_committed_sp_outputs. --- spdk-wallet/src/client/spend.rs | 104 +++++++++++++++++++------------- 1 file changed, 63 insertions(+), 41 deletions(-) diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index 3f269ebb..0772e84c 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -82,6 +82,36 @@ pub fn propose_drain_selection( select_all_utxos_for_fee_rate(&utxos, &[placeholder], fee_rate) } +enum SpOutputScripts { + None, + Pending, + Committed, +} + +fn sp_output_scripts(psbt: &Psbt) -> Result { + let mut pending = false; + let mut committed = false; + for output in psbt + .outputs + .iter() + .filter(|output| output.sp_v0_info.is_some()) + { + if output.script_pubkey.is_empty() { + pending = true; + } else { + committed = true; + } + } + match (pending, committed) { + (true, true) => Err(Error::msg( + "silent payment outputs are only partially derived", + )), + (false, false) => Ok(SpOutputScripts::None), + (true, false) => Ok(SpOutputScripts::Pending), + (false, true) => Ok(SpOutputScripts::Committed), + } +} + impl SpClient { fn validate_recipient_networks(recipients: &[Recipient], network: Network) -> Result<()> { let sp_network = sp_network_from_network(network); @@ -250,34 +280,15 @@ impl SpClient { /// present, then commits the scripts. A PSBT with no silent-payment outputs /// is returned unchanged. Requires the spend secret when shares are missing. /// - /// When every silent-payment output already has a script, the scripts are - /// checked against the shares instead of being trusted. This wallet signs - /// every input, so that is the set passed to the check. + /// Scripts that are already set are not checked here. Use + /// [`Self::verify_committed_sp_outputs`]. pub fn commit_sp_outputs(&self, mut psbt: Psbt) -> Result { - let mut pending = false; - let mut committed = false; - for output in &psbt.outputs { - if output.sp_v0_info.is_none() { - continue; - } - if output.script_pubkey.is_empty() { - pending = true; - } else { - committed = true; - } - } - if pending && committed { - return Err(Error::msg( - "silent payment outputs are only partially derived", - )); - } - if !pending { - if committed { - let secp = Secp256k1::new(); - let signed_inputs: Vec = (0..psbt.inputs.len()).collect(); - psbt.verify_before_signing(&secp, &signed_inputs)?; + match sp_output_scripts(&psbt)? { + SpOutputScripts::None => return Ok(psbt), + SpOutputScripts::Committed => { + return Err(Error::msg("silent payment outputs are already derived")); } - return Ok(psbt); + SpOutputScripts::Pending => {} } let secp = Secp256k1::new(); @@ -297,6 +308,23 @@ impl SpClient { Ok(signer.psbt()) } + /// Checks silent-payment scripts that are already set. Does not write them. + /// + /// A PSBT with no silent-payment outputs is accepted. Empty scripts are + /// rejected: [`Self::commit_sp_outputs`] has to run first. This wallet signs + /// every input, so that is the set passed to the check. + pub fn verify_committed_sp_outputs(&self, psbt: &Psbt) -> Result<()> { + match sp_output_scripts(psbt)? { + SpOutputScripts::None => Ok(()), + SpOutputScripts::Pending => Err(Error::msg("silent payment outputs are not derived")), + SpOutputScripts::Committed => { + let secp = Secp256k1::new(); + let signed_inputs: Vec = (0..psbt.inputs.len()).collect(); + Ok(psbt.verify_before_signing(&secp, &signed_inputs)?) + } + } + } + /// Signs every input this wallet can sign. Does not finalize witnesses. /// /// Silent-payment output scripts must already be set. BIP-375 forbids a @@ -636,20 +664,13 @@ mod tests { .create_transaction_from_proposal(&utxos, recipients, &selection, Network::Regtest) .expect("transaction"); let mut psbt = client.commit_sp_outputs(psbt).expect("commit"); - let recommitted = client - .commit_sp_outputs(psbt.clone()) + client + .verify_committed_sp_outputs(&psbt) .expect("an already committed PSBT must still verify"); - assert_eq!( - recommitted - .outputs - .iter() - .map(|output| output.script_pubkey.clone()) - .collect::>(), - psbt.outputs - .iter() - .map(|output| output.script_pubkey.clone()) - .collect::>() - ); + let err = client + .commit_sp_outputs(psbt.clone()) + .expect_err("commit must refuse scripts that are already set"); + assert!(err.to_string().contains("already derived")); let change_vout = psbt .outputs @@ -663,7 +684,7 @@ mod tests { ScriptBuf::new_p2tr_tweaked(xonly.dangerous_assume_tweaked()); let err = client - .commit_sp_outputs(psbt.clone()) + .verify_committed_sp_outputs(&psbt) .expect_err("a swapped silent payment script must be rejected"); assert!(err.to_string().contains("does not match")); @@ -671,7 +692,8 @@ mod tests { .sign_inputs(psbt) .expect_err("signing a swapped silent payment script must be rejected"); assert!( - err.chain().any(|cause| cause.to_string().contains("does not match")), + err.chain() + .any(|cause| cause.to_string().contains("does not match")), "{err:#}" ); } From 0d3f4521c13021a9ba77d45c9211e44bec3043c5 Mon Sep 17 00:00:00 2001 From: Sosthene Date: Wed, 4 Nov 2026 16:17:26 +0100 Subject: [PATCH 13/13] refactor(spdk-wallet): resolve selected outpoints while assembling A missing outpoint fails inside assembly. The duplicate-outpoint preflight is dropped with the separate lookup. --- spdk-wallet/src/client/spend.rs | 55 +++++++++------------------------ 1 file changed, 14 insertions(+), 41 deletions(-) diff --git a/spdk-wallet/src/client/spend.rs b/spdk-wallet/src/client/spend.rs index 0772e84c..a5dd496e 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -1,4 +1,4 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use anyhow::{Error, Result}; use bitcoin::bip32::{DerivationPath, Fingerprint}; @@ -18,9 +18,7 @@ use silentpayments::Network as SpNetwork; use spdk_core::scanner::DiscoveredOutput; use super::coin_select::{pick_utxos_for_fee_rate, select_all_utxos_for_fee_rate}; -use super::{ - CoinSelectProposal, DrainSelection, FeeRate, Recipient, RecipientAddress, SpClient, -}; +use super::{CoinSelectProposal, DrainSelection, FeeRate, Recipient, RecipientAddress, SpClient}; const fn sp_network_from_network(network: Network) -> SpNetwork { match network { @@ -127,30 +125,6 @@ impl SpClient { Ok(()) } - fn resolve_selected_utxos( - available_utxos: &HashMap, - selected: &[OutPoint], - ) -> Result> { - let res = selected - .iter() - .map(|outpoint| { - if let Some(output) = available_utxos.get(outpoint) { - Ok((*outpoint, output.clone())) - } else { - Err(Error::msg(format!( - "outpoint {outpoint} not found in available_utxos" - ))) - } - }) - .collect::>>()?; - if res.len() != selected.len() { - return Err(Error::msg( - "All selected outpoints are not in provided utxos", - )); - } - Ok(res) - } - fn assemble_unsigned( &self, available_utxos: &HashMap, @@ -159,14 +133,17 @@ impl SpClient { network: Network, ) -> Result { Self::validate_recipient_networks(recipients, network)?; - let selected_utxos = Self::resolve_selected_utxos(available_utxos, selected_outpoints)?; let spend_pubkey = CompressedPublicKey(PublicKey::from(&self.spend_key())); // Inputs and outputs are fixed by coin selection. Freeze them here so a // later ECDH share cannot be computed against a different input set. let mut constructor = Constructor::::default(); - for (outpoint, output) in &selected_utxos { - constructor = constructor.input(input_for_utxo(spend_pubkey, outpoint, output)); + for outpoint in selected_outpoints.iter() { + if let Some(output) = available_utxos.get(outpoint) { + constructor = constructor.input(input_for_utxo(spend_pubkey, outpoint, output)); + } else { + return Err(Error::msg(format!("{outpoint} isn't part of this wallet"))); + } } for recipient in recipients { constructor = constructor.output(output_for_recipient(recipient, network)?)?; @@ -215,15 +192,6 @@ impl SpClient { )); } - // Check that there's no duplicate selection - let selected_utxos = selection.selected_utxos(); - let mut selected_seen = HashSet::with_capacity(selected_utxos.len()); - for outpoint in selected_utxos { - if !selected_seen.insert(outpoint) { - return Err(Error::msg("Duplicate outpoint in selected_utxos")); - } - } - if selection.change() > Amount::ZERO { recipients.push(Recipient { address: RecipientAddress::SpCode(self.sp_receiver.change_code()), @@ -232,7 +200,12 @@ impl SpClient { } recipients.shuffle(&mut thread_rng()); - self.assemble_unsigned(available_utxos, selected_utxos, &recipients, network) + self.assemble_unsigned( + available_utxos, + selection.selected_utxos(), + &recipients, + network, + ) } /// Builds an unsigned drain PSBT from a [`DrainSelection`].