diff --git a/Cargo.toml b/Cargo.toml index b0ea293a..fe0972ed 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,7 @@ members = [ "spdk-wallet", "silentpayments", "scanners/local", + "psbt" ] resolver = "3" @@ -15,15 +16,16 @@ 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" 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"] } -bitcoin_hashes = "0.13.0" +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"] } futures = "0.3" @@ -36,6 +38,21 @@ reqwest = { version = "0.12.4", features = [ "rustls-tls", "gzip", ], default-features = false } +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 +# 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" } [workspace.package] 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/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/extractor.rs b/psbt/src/extractor.rs new file mode 100644 index 00000000..e3741d02 --- /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.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.into(), + ) + .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 new file mode 100644 index 00000000..49fa86c7 --- /dev/null +++ b/psbt/src/lib.rs @@ -0,0 +1,12 @@ +//! BIP-375 extensions for `psbt-v2` PSBTs. +//! +//! - [`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 extractor; +pub mod signer; diff --git a/psbt/src/signer.rs b/psbt/src/signer.rs new file mode 100644 index 00000000..3b08916f --- /dev/null +++ b/psbt/src/signer.rs @@ -0,0 +1,987 @@ +//! 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`. 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; + +use bitcoin::key::TweakedPublicKey; +use bitcoin::{CompressedPublicKey, ScriptBuf, XOnlyPublicKey}; +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; +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 }, + /// 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, + 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 `psbt_v2::GetKey`, so the global share cannot cover every input. + KeyResolution { vin: usize }, + /// 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, + /// 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), + /// 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 { + 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::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}") + } + 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::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" + ), + } + } +} + +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) + } +} + +/// 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; + + /// 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 { + 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, vin)? { + 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, + { + if self + .outputs + .iter() + .all(|output| output.sp_v0_info.is_none()) + { + return Ok(Vec::new()); + } + + // The BIP-352 input set, exactly as the receiver rebuilds it. + 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.into(), + )?; + let spk = funding_output(input)?.script_pubkey.to_bytes(); + 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); + } + + derive_sp_output_scripts_from_inputs(self, secp, &transaction_inputs) + } + + 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. +/// +/// 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. +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. +/// +/// Shared by the signer and the extractor so both hash the same script. +/// +/// [`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 these roles are 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 neither role uses 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. +pub(crate) 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`. 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 +/// 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. +/// +/// # 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); + } + + 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 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() { + 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); + } + 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 pubkey.compressed && 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": "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" + }, + "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": "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..bf96915a --- /dev/null +++ b/psbt/tests/bip375_vectors.rs @@ -0,0 +1,282 @@ +//! 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::extractor::{SpExtractorError, SpExtractorExt}; +use psbt::signer::SpSignerExt; +use psbt_v2::{Finalizer, Psbt, Signer, 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 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 { + 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() + ); +} + +/// 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 new file mode 100644 index 00000000..5c1c84b9 --- /dev/null +++ b/psbt/tests/signer.rs @@ -0,0 +1,1576 @@ +//! 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). +//! 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; + +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::signer::{ + ShareMode, SpOutputVerifier, SpSignerError, SpSignerExt, extract_eligible_input_pubkey, +}; +use psbt_v2::{ + 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, get_pubkey_from_input}; +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 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() +} + +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: usize = input.spent_output_index.into(); + 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 +} + +/// 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()), + 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 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.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.into(), + ) + .unwrap(); + let spk = input + .funding_utxo_untrusted() + .unwrap() + .script_pubkey + .to_bytes(); + let pubkey = extract_eligible_input_pubkey(input, vin).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); + 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( + 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); + + commit_derived_outputs(&mut psbt, &secp); + + 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); + commit_derived_outputs(&mut psbt, &secp); + + 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, 0).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, 0).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, 0).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, 0).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, 0).unwrap(); + assert!( + result.is_none(), + "P2SH with non-P2WPKH redeem must be ineligible" + ); +} + +/// 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_errors() { + 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, 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] +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, 0).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, 0).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.into()), + 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); + commit_derived_outputs(&mut psbt, &secp); + + 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(); + + commit_derived_outputs(&mut psbt_alice, &secp); + + 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" + ); +} + +// ── 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(); + + commit_derived_outputs(&mut psbt, &secp); + + 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.into()) + .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.into()) + .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(); + commit_derived_outputs(&mut psbt, secp); + 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(); + commit_derived_outputs(&mut psbt, &secp); + 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(); + commit_derived_outputs(&mut psbt, &secp); + + 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.into(), + ) + .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(); + commit_derived_outputs(&mut psbt, &secp); + + 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.into(), + ) + .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(); + commit_derived_outputs(&mut psbt, &secp); + + 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.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_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.into(), + ) + .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(); + commit_derived_outputs(&mut psbt, &secp); + 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(); + commit_derived_outputs(&mut psbt, &secp); + + 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/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/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/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/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/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 51c7fb00..05130b22 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,19 +16,29 @@ 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; #[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; +#[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; +pub use utils::common::SilentPaymentKeyMaterial; +pub use utils::common::SpVersion; +#[cfg(any(feature = "sending", feature = "receiving"))] +pub use utils::common::{NonEmptyArray, TransactionInputs, TransactionSharedSecret}; 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..e384d5ba 100644 --- a/silentpayments/src/sending.rs +++ b/silentpayments/src/sending.rs @@ -1,92 +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::{SharedSecret, SilentPaymentKeyMaterial, 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(); - 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(); 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.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 85a33977..b382c2c7 100644 --- a/silentpayments/src/utils/common.rs +++ b/silentpayments/src/utils/common.rs @@ -1,22 +1,36 @@ #[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(any(feature = "sending", feature = "receiving"))] -use bitcoin_hashes::Hash as _; +#[cfg(feature = "encode")] +use core::fmt; use secp256k1::PublicKey; use secp256k1::constants::PUBLIC_KEY_SIZE; #[cfg(any(feature = "sending", feature = "receiving"))] -use secp256k1::{Scalar, Secp256k1, SecretKey}; - +use secp256k1::ecdh::shared_secret_point; #[cfg(any(feature = "sending", feature = "receiving"))] -use crate::utils::hash::SharedSecretHash; -use crate::{Error, Result}; +use secp256k1::{Scalar, Secp256k1, SecretKey}; /// Struct representing an `OutPoint` type. /// @@ -87,25 +101,283 @@ 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"))] -#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)] -pub struct SharedSecret(pub(crate) PublicKey); +#[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), + } + } -impl From for SharedSecret { - fn from(value: PublicKey) -> Self { - Self(value) + /// 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) + } + + #[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)?) } } -impl From for PublicKey { - fn from(value: SharedSecret) -> Self { - value.0 +/// 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 TransactionSharedSecret { + ecdh_shared_secret: PublicKey, + recipient_scan_key: PublicKey, +} + +#[expect(clippy::missing_const_for_fn)] +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 + /// + /// * `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 + } + + 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) @@ -440,7 +712,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/hash.rs b/silentpayments/src/utils/hash.rs index 081db4b6..cf29141f 100644 --- a/silentpayments/src/utils/hash.rs +++ b/silentpayments/src/utils/hash.rs @@ -1,8 +1,7 @@ +use crate::utils::common::{OutPoint, TransactionSharedSecret}; use bitcoin_hashes::{Hash as _, HashEngine as _, sha256t_hash_newtype}; use secp256k1::{PublicKey, Scalar, SecretKey}; -use crate::utils::common::{NonEmptyArray, OutPoint, SharedSecret}; - sha256t_hash_newtype! { struct InputsTag = hash_str("BIP0352/Inputs"); @@ -12,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"); @@ -58,17 +57,22 @@ 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) } } -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() +} + +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 bd3bec14..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, 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 c3e978b2..9f51980c 100644 --- a/silentpayments/src/utils/sending.rs +++ b/silentpayments/src/utils/sending.rs @@ -1,130 +1,273 @@ //! Sending utility functions. -use secp256k1::constants::SECRET_KEY_SIZE; -use secp256k1::ecdh::shared_secret_point; -use secp256k1::{PublicKey, Secp256k1, SecretKey}; +//! +//! 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, and pass to [`generate_recipient_pubkeys`](crate::sending::generate_recipient_pubkeys). -use super::hash::calculate_input_hash; -use crate::utils::common::{NonEmptyArray, OutPoint, SharedSecret}; +use crate::utils::common::{NonEmptyArray, ecdh_multiply}; use crate::{Error, Result}; +use rust_dleq::{DleqProof, generate_dleq_proof, verify_dleq_proof}; +use secp256k1::{PublicKey, Secp256k1, SecretKey, Signing, Verification}; -/// 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); +/// 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); -impl PartialSecret { - /// Re-construct the partial secret from the inner bytes. - pub fn from_slice(data: &[u8]) -> Result { - Ok(Self(SecretKey::from_slice(data)?)) +#[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) } - /// Returns the inner bytes of the partial secret - pub fn secret_bytes(&self) -> [u8; SECRET_KEY_SIZE] { - self.0.secret_bytes() + pub fn as_inner(&self) -> &SecretKey { + &self.0 } -} -impl From for PartialSecret { - fn from(value: SecretKey) -> Self { - Self(value) + pub fn into_inner(self) -> SecretKey { + self.0 } } -impl From for SecretKey { - fn from(value: PartialSecret) -> Self { - value.0 +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) } } -/// 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. +/// ECDH share for a single eligible input: `a_i * B_scan` (before input hash). /// -/// # 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)?; +/// 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, +} - let secp = Secp256k1::signing_only(); - let A_sum = a_sum.public_key(&secp); +#[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, + }) + } - let outpoints = NonEmptyArray::new(outpoints_data)?; - let input_hash = calculate_input_hash(&outpoints, A_sum); + 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 + } - Ok(PartialSecret(a_sum.mul_tweak(&input_hash)?)) + 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(()) + } } -/// 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 +/// ECDH share for all eligible inputs combined. /// -/// * `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, -) -> 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")) +/// 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, } -fn get_a_sum_secret_keys(input: &[(SecretKey, bool)]) -> Result { - if input.is_empty() { - return Err(Error::GenericError("No input provided".to_owned())); +#[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, + }) } - let secp = secp256k1::Secp256k1::new(); + 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, + } + } - let mut negated_keys: Vec = vec![]; + /// 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(()) + } - for (key, is_taproot) in input { - let (_, parity) = key.x_only_public_key(&secp); + pub fn recipient_scan_key(&self) -> &PublicKey { + &self.recipient_scan_key + } - if *is_taproot && parity == secp256k1::Parity::Odd { - negated_keys.push(key.negate()); - } else { - negated_keys.push(*key); - } + pub fn as_ecdh_shared_secret(&self) -> &PublicKey { + &self.ecdh_shared_secret } - let (head, tail) = negated_keys.split_first().expect("input is non-empty"); + 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 result: SecretKey = tail - .iter() - .try_fold(*head, |acc, &item| acc.add_tweak(&item.into()))?; + let global_share = GlobalSenderEcdhShare::new_from_summed_keys( + &secp, + recipient_scan_key, + NonEmptyArray::new(&[NormalizedSecretKey::new(&secp, private_key, false)]).unwrap(), + &aux_rand, + ) + .unwrap(); - Ok(result) + 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(); + } } diff --git a/silentpayments/tests/vector_tests.rs b/silentpayments/tests/vector_tests.rs index d053a61b..6b176eea 100644 --- a/silentpayments/tests/vector_tests.rs +++ b/silentpayments/tests/vector_tests.rs @@ -2,18 +2,18 @@ mod common; #[cfg(test)] mod tests { - use std::collections::HashSet; + use std::collections::{HashMap, 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::{GlobalSenderEcdhShare, NormalizedSecretKey}; + use silentpayments::{ + Network, NonEmptyArray, SilentPaymentCode, TransactionInputs, TransactionSharedSecret, }; - use silentpayments::utils::sending::calculate_partial_secret; - use silentpayments::{Network, SilentPaymentCode}; use crate::common::structs::TestData; use crate::common::utils::{self, verify_and_calculate_signatures}; @@ -39,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; } @@ -66,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 { @@ -104,29 +133,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,16 +179,18 @@ 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) .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/Cargo.toml b/spdk-wallet/Cargo.toml index c578f3eb..e7044baf 100644 --- a/spdk-wallet/Cargo.toml +++ b/spdk-wallet/Cargo.toml @@ -12,6 +12,8 @@ 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 +psbt-v2.workspace = true anyhow.workspace = true bitcoin.workspace = true @@ -21,6 +23,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 +32,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(); 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 9eecb170..a5dd496e 100644 --- a/spdk-wallet/src/client/spend.rs +++ b/spdk-wallet/src/client/spend.rs @@ -1,25 +1,24 @@ use std::collections::HashMap; 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::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::PartialSecret; -use silentpayments::{Network as SpNetwork, SilentPaymentCode, utils as sp_utils}; +use psbt::extractor::SpExtractorExt as _; +use psbt::signer::{ShareMode, SpOutputVerifier, 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, -}; +use super::{CoinSelectProposal, DrainSelection, FeeRate, Recipient, RecipientAddress, SpClient}; const fn sp_network_from_network(network: Network) -> SpNetwork { match network { @@ -32,11 +31,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], @@ -56,7 +55,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, @@ -81,6 +80,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); @@ -96,62 +125,43 @@ impl SpClient { Ok(()) } - fn resolve_selected_utxos( - available_utxos: &HashMap, - selected: &[OutPoint], - ) -> Result> { - 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() - } - - #[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)?; - let selected_utxos = Self::resolve_selected_utxos(available_utxos, selected_outpoints)?; - let partial_secret = self.partial_secret_for_selected_utxos(&selected_utxos)?; - Ok(SilentPaymentUnsignedTransaction { - selected_utxos, - recipients, - partial_secret, - unsigned_tx: None, - network, - change, - change_index, - fee, - actual_fee_rate, - strategy, - }) + ) -> Result { + Self::validate_recipient_networks(recipients, network)?; + 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 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)?)?; + } + 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 @@ -162,7 +172,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( @@ -182,41 +192,33 @@ impl SpClient { )); } - let (wallet_change, change_index) = if selection.change() > Amount::ZERO { - let change_index = recipients.len(); + 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, + &recipients, network, - wallet_change, - change_index, - selection.fee(), - selection.actual_fee_rate(), - Some(selection.strategy()), ) } - /// 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( @@ -241,243 +243,220 @@ 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(); - - let sp_key_material2xonlypubkeys = silentpayments::sending::generate_recipient_pubkeys( - recipient_codes, - unsigned_transaction.partial_secret, - )?; + /// 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. + /// + /// 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 { + match sp_output_scripts(&psbt)? { + SpOutputScripts::None => return Ok(psbt), + SpOutputScripts::Committed => { + return Err(Error::msg("silent payment outputs are already derived")); + } + SpOutputScripts::Pending => {} + } - 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 secp = Secp256k1::new(); + 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)?; + } + let scripts = psbt.derive_sp_output_scripts(&secp)?; + let mut signer = Signer::new(psbt)?; + signer.commit_silent_payment_outputs(scripts)?; + Ok(signer.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) + /// 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)?) + } + } } - 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")) + /// 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 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(", "), + ) })?; - - 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) + (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 partial_secret_for_selected_utxos( - &self, - selected_utxos: &[(OutPoint, DiscoveredOutput)], - ) -> Result { - let b_spend = self.try_secret_spend_key()?; + /// 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)?) + } - let outpoints = selected_utxos - .iter() - .map(|(outpoint, _)| { - Ok(sp_utils::OutPoint::from_txid_and_vout( - &outpoint.txid.to_string(), - outpoint.vout, - )?) - }) - .collect::>>()?; + /// 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)?) + } - let input_privkeys = selected_utxos - .iter() - .map(|(_, output)| Ok((b_spend.add_tweak(&output.tweak)?, true))) - .collect::>>()?; + /// 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()?) + } +} - let partial_secret = - sp_utils::sending::calculate_partial_secret(&input_privkeys, &outpoints)?; +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 +} - Ok(partial_secret) +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) + } + 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), + })) + } } } #[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::*; 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 when committing silent-payment outputs 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 +464,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() @@ -527,7 +506,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(), @@ -536,9 +515,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] @@ -593,22 +594,80 @@ 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())); + } + + #[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"); + client + .verify_committed_sp_outputs(&psbt) + .expect("an already committed PSBT must still verify"); + 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 + .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 + .verify_committed_sp_outputs(&psbt) + .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:#}" + ); } } diff --git a/spdk-wallet/src/client/structs.rs b/spdk-wallet/src/client/structs.rs index 3bbd20b4..8494707f 100644 --- a/spdk-wallet/src/client/structs.rs +++ b/spdk-wallet/src/client/structs.rs @@ -8,13 +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::utils::sending::PartialSecret; -use spdk_core::scanner::DiscoveredOutput; - -use super::coin_select::Strategy; #[derive(Debug, Clone, PartialEq)] pub enum RecipientAddress { @@ -57,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 partial_secret: PartialSecret, - 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 0a938b21..fa3830e5 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,8 @@ pub use bitcoin; // re-export local scanner if enabled #[cfg(feature = "local-scanner")] pub use local_scanner::SpScanner; +// 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};