From e0e26b5684d418b73c2868e7cade10655ff78934 Mon Sep 17 00:00:00 2001 From: Matthew Date: Thu, 23 Jul 2026 13:23:08 -0400 Subject: [PATCH 1/2] build: add optional bdk_sp dependency --- bdk-ffi/Cargo.lock | 10 ++++++++++ bdk-ffi/Cargo.toml | 4 ++++ 2 files changed, 14 insertions(+) diff --git a/bdk-ffi/Cargo.lock b/bdk-ffi/Cargo.lock index 5cd2a13e..c643dbbf 100644 --- a/bdk-ffi/Cargo.lock +++ b/bdk-ffi/Cargo.lock @@ -147,6 +147,7 @@ dependencies = [ "bdk_electrum", "bdk_esplora", "bdk_kyoto", + "bdk_sp", "bdk_wallet", "thiserror", "uniffi", @@ -206,6 +207,15 @@ dependencies = [ "bip157", ] +[[package]] +name = "bdk_sp" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c401af00a119ceee1bd9aa35dd15c9130b5d8381003b141fb5456a938ab8efed" +dependencies = [ + "bitcoin", +] + [[package]] name = "bdk_wallet" version = "3.1.0" diff --git a/bdk-ffi/Cargo.toml b/bdk-ffi/Cargo.toml index 3f9fdc8f..868f6eda 100644 --- a/bdk-ffi/Cargo.toml +++ b/bdk-ffi/Cargo.toml @@ -14,7 +14,11 @@ name = "bdkffi" name = "uniffi-bindgen" path = "uniffi-bindgen.rs" +[features] +experimental-silent-payments = ["dep:bdk_sp"] + [dependencies] +bdk_sp = { version = "0.2.0", optional = true } bdk_wallet = { version = "=3.1.0", features = ["all-keys", "keys-bip39", "rusqlite"] } bdk_esplora = { version = "0.22.2", default-features = false, features = ["std", "blocking", "blocking-https-rustls"] } bdk_electrum = { version = "0.24.0", default-features = false, features = ["use-rustls-ring"] } From 8337acbbd70f8e49c8d8be8e7c2c3073a7e4b570 Mon Sep 17 00:00:00 2001 From: Matthew Date: Mon, 27 Jul 2026 10:23:39 -0500 Subject: [PATCH 2/2] feat: add experimental silent payment sending --- .github/workflows/rust-ci.yaml | 6 + bdk-ffi/src/lib.rs | 2 + bdk-ffi/src/silent_payments.rs | 221 +++++++++++++++ bdk-ffi/src/tests/mod.rs | 2 + bdk-ffi/src/tests/silent_payments.rs | 403 +++++++++++++++++++++++++++ bdk-ffi/src/tx_builder.rs | 191 +++++++++++++ 6 files changed, 825 insertions(+) create mode 100644 bdk-ffi/src/silent_payments.rs create mode 100644 bdk-ffi/src/tests/silent_payments.rs diff --git a/.github/workflows/rust-ci.yaml b/.github/workflows/rust-ci.yaml index 7300113d..845aabd9 100644 --- a/.github/workflows/rust-ci.yaml +++ b/.github/workflows/rust-ci.yaml @@ -47,6 +47,9 @@ jobs: - name: "Test" run: CLASSPATH=./tests/jna/jna-5.14.0.jar cargo test --features uniffi/bindgen-tests + - name: "Test experimental silent payments" + run: CLASSPATH=./tests/jna/jna-5.14.0.jar cargo test --features "experimental-silent-payments uniffi/bindgen-tests" + check: name: "Run clippy and fmt" needs: test @@ -70,3 +73,6 @@ jobs: - name: "Check clippy" run: cargo clippy --all-targets --features "uniffi/bindgen-tests" + + - name: "Check clippy with experimental silent payments" + run: cargo clippy --all-targets --features "experimental-silent-payments uniffi/bindgen-tests" diff --git a/bdk-ffi/src/lib.rs b/bdk-ffi/src/lib.rs index 8ee2026d..e52d41e9 100644 --- a/bdk-ffi/src/lib.rs +++ b/bdk-ffi/src/lib.rs @@ -7,6 +7,8 @@ mod keys; mod kyoto; mod macros; mod signer; +#[cfg(feature = "experimental-silent-payments")] +mod silent_payments; mod store; mod tx_builder; mod types; diff --git a/bdk-ffi/src/silent_payments.rs b/bdk-ffi/src/silent_payments.rs new file mode 100644 index 00000000..7b78715f --- /dev/null +++ b/bdk-ffi/src/silent_payments.rs @@ -0,0 +1,221 @@ +use crate::bitcoin::{Amount, Network}; + +use bdk_sp::bitcoin::bech32::primitives::{decode::CheckedHrpstring, Bech32m}; +use bdk_sp::encoding::{ + ParseError as BdkSilentPaymentCodeParseError, SilentPaymentCode as BdkSilentPaymentCode, +}; +use bdk_sp::send::error::SpSendError; + +use std::convert::TryFrom; +use std::fmt::Display; +use std::sync::Arc; + +/// Represents a silent payment code containing the necessary keys and network information. +#[derive(Clone, Debug, Eq, PartialEq, uniffi::Object)] +#[uniffi::export(Eq, Display)] +pub struct SilentPaymentCode(pub(crate) BdkSilentPaymentCode); + +#[uniffi::export] +impl SilentPaymentCode { + /// Attempts to parse a string as a silent payment code. + #[uniffi::constructor] + pub fn new(code: String) -> Result { + let checked_code = CheckedHrpstring::new::(&code).map_err(|error| { + SilentPaymentCodeParseError::Bech32 { + error_message: error.to_string(), + } + })?; + if checked_code + .fe32_iter::<&mut dyn Iterator>() + .next() + .is_none() + { + return Err(SilentPaymentCodeParseError::Version { + error_message: "payload length does not match version spec".to_string(), + }); + } + + BdkSilentPaymentCode::try_from(code.as_str()) + .map(Self) + .map_err(SilentPaymentCodeParseError::from) + } + + /// Returns whether this silent payment code can be used on `network`. + pub fn is_valid_for_network(&self, network: Network) -> bool { + matches!( + (self.0.network, network), + (Network::Bitcoin, Network::Bitcoin) + | (Network::Regtest, Network::Regtest) + | ( + Network::Testnet | Network::Testnet4 | Network::Signet, + Network::Testnet | Network::Testnet4 | Network::Signet + ) + ) + } +} + +impl Display for SilentPaymentCode { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.0.fmt(f) + } +} + +/// A silent payment code and associated amount. +#[derive(uniffi::Record)] +pub struct SilentPaymentRecipient { + /// The recipient's silent payment code. + pub code: Arc, + /// The amount to send. + pub amount: Arc, +} + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum SilentPaymentCodeParseError { + #[error("invalid Bech32m silent payment code: {error_message}")] + Bech32 { error_message: String }, + + #[error("unsupported silent payment code version: {error_message}")] + Version { error_message: String }, + + #[error("unsupported silent payment code human-readable prefix: {error_message}")] + UnknownHrp { error_message: String }, + + #[error("invalid silent payment public key: {error_message}")] + InvalidPublicKey { error_message: String }, +} + +impl From for SilentPaymentCodeParseError { + fn from(error: BdkSilentPaymentCodeParseError) -> Self { + match error { + BdkSilentPaymentCodeParseError::Bech32(error) => Self::Bech32 { + error_message: error.to_string(), + }, + BdkSilentPaymentCodeParseError::Version(error) => Self::Version { + error_message: error.to_string(), + }, + BdkSilentPaymentCodeParseError::UnknownHrp(error) => Self::UnknownHrp { + error_message: error.to_string(), + }, + BdkSilentPaymentCodeParseError::InvalidPubKey(error) => Self::InvalidPublicKey { + error_message: error.to_string(), + }, + } + } +} + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum SilentPaymentSendError { + #[error("at least one silent payment recipient is required")] + NoRecipients, + + #[error("a silent payment scan key cannot have more than 2323 recipients")] + RecipientLimitExceeded, + + #[error("silent payment code {code} is not valid for wallet network {wallet_network}")] + NetworkMismatch { + code: String, + wallet_network: String, + }, + + #[error("foreign inputs are not supported for silent payment sending")] + ForeignInputsUnsupported, + + #[error("only_witness_utxo is not supported for silent payment sending")] + OnlyWitnessUtxoUnsupported, + + #[error("P2SH inputs are not supported for silent payment sending")] + P2shInputsUnsupported, + + #[error("replace-by-fee is not supported for silent payment sending")] + RbfUnsupported, + + #[error("silent payment sending only supports SIGHASH_ALL or Taproot SIGHASH_DEFAULT")] + UnsupportedSighash, + + #[error("failed to create silent payment transaction: {error_message}")] + CreateTransaction { error_message: String }, + + #[error("the initial silent payment signing pass failed: {error_message}")] + InitialSigning { error_message: String }, + + #[error("the wallet could not finalize the initial silent payment signing pass")] + InitialSigningIncomplete, + + #[error("silent payment secp256k1 derivation failed: {error_message}")] + Secp256k1 { error_message: String }, + + #[error("silent payment BIP32 derivation failed: {error_message}")] + Bip32 { error_message: String }, + + #[error("silent payment derivation requires at least one input outpoint: {error_message}")] + NoOutpoints { error_message: String }, + + #[error("no eligible inputs are available for silent payment derivation")] + MissingInputsForSharedSecretDerivation, + + #[error("an input is missing its finalized witness")] + MissingWitness, + + #[error("an input is missing its previous output")] + MissingPrevout, + + #[error("a transaction output index is invalid: {error_message}")] + OutputIndex { error_message: String }, + + #[error("the PSBT is missing a silent payment placeholder output")] + MissingPlaceholderScript, + + #[error("a required private key for an eligible silent payment input is unavailable")] + MissingEligibleInputKey, + + #[error("there are fewer silent payment derivations than placeholder outputs")] + MissingDerivations, + + #[error("there are fewer placeholder outputs than silent payment derivations")] + MissingOutputs, + + #[error( + "expected {expected} silent payment placeholder outputs in the built transaction, found {actual}" + )] + PlaceholderOutputMismatch { expected: u64, actual: u64 }, + + #[error("silent payment output derivation left a placeholder output in the transaction")] + PlaceholderNotReplaced, + + #[error("the final silent payment signing pass failed: {error_message}")] + FinalSigning { error_message: String }, + + #[error("the wallet could not finalize the final silent payment signing pass")] + FinalSigningIncomplete, + + #[error("failed to extract the signed silent payment transaction: {error_message}")] + ExtractTransaction { error_message: String }, +} + +impl From for SilentPaymentSendError { + fn from(error: SpSendError) -> Self { + match error { + SpSendError::Secp256k1Error(error) => Self::Secp256k1 { + error_message: error.to_string(), + }, + SpSendError::Bip32Error(error) => Self::Bip32 { + error_message: error.to_string(), + }, + SpSendError::NoOutpoints(error) => Self::NoOutpoints { + error_message: error.to_string(), + }, + SpSendError::MissingInputsForSharedSecretDerivation => { + Self::MissingInputsForSharedSecretDerivation + } + SpSendError::MissingWitness => Self::MissingWitness, + SpSendError::MissingPrevout => Self::MissingPrevout, + SpSendError::IndexError(error) => Self::OutputIndex { + error_message: error.to_string(), + }, + SpSendError::MissingPlaceholderScript => Self::MissingPlaceholderScript, + SpSendError::KeyError => Self::MissingEligibleInputKey, + SpSendError::MissingDerivations => Self::MissingDerivations, + SpSendError::MissingOutputs => Self::MissingOutputs, + } + } +} diff --git a/bdk-ffi/src/tests/mod.rs b/bdk-ffi/src/tests/mod.rs index e67527cf..09303f73 100644 --- a/bdk-ffi/src/tests/mod.rs +++ b/bdk-ffi/src/tests/mod.rs @@ -2,5 +2,7 @@ mod bitcoin; mod descriptor; mod error; mod keys; +#[cfg(feature = "experimental-silent-payments")] +mod silent_payments; mod tx_builder; mod wallet; diff --git a/bdk-ffi/src/tests/silent_payments.rs b/bdk-ffi/src/tests/silent_payments.rs new file mode 100644 index 00000000..9ba97b46 --- /dev/null +++ b/bdk-ffi/src/tests/silent_payments.rs @@ -0,0 +1,403 @@ +use crate::bitcoin::{Amount, Network, NetworkKind, Transaction}; +use crate::descriptor::Descriptor; +use crate::silent_payments::{ + SilentPaymentCode, SilentPaymentCodeParseError, SilentPaymentRecipient, SilentPaymentSendError, +}; +use crate::store::Persister; +use crate::tx_builder::TxBuilder; +use crate::types::UnconfirmedTx; +use crate::wallet::Wallet; + +use bdk_sp::receive::scan::Scanner; +use bdk_wallet::bitcoin::{ + absolute::LockTime, ecdsa, hashes::Hash, sighash::SighashCache, transaction::Version, + Amount as BdkAmount, CompressedPublicKey, OutPoint as BdkOutPoint, PrivateKey, ScriptBuf, + Sequence, Transaction as BdkTransaction, TxIn as BdkTxIn, TxOut as BdkTxOut, Txid as BdkTxid, + Witness, XOnlyPublicKey, +}; +use bdk_wallet::KeychainKind; + +use std::collections::BTreeMap; +use std::sync::Arc; + +const TSP_CODE: &str = + "tsp1qq0u4yswlkqx36shz7j8mwt335p4el5txc8tt6yny3dqewlw4rwdqkqewtzh728u7mzkne3uf0a35mzqlm0jf4q2kgc5aakq4d04a9l734uxwehmt"; +const REGTEST_CODE: &str = + "sprt1qqw7zfpjcuwvq4zd3d4aealxq3d669s3kcde4wgr3zl5ugxs40twv2qccgvszutt7p796yg4h926kdnty66wxrfew26gu2gk5h5hcg4s2jqyascfz"; + +#[test] +fn silent_payment_code_roundtrips_and_checks_network_family() { + let testnet_code = SilentPaymentCode::new(TSP_CODE.to_string()).unwrap(); + assert_eq!(testnet_code.to_string(), TSP_CODE); + assert!(testnet_code.is_valid_for_network(Network::Testnet)); + assert!(testnet_code.is_valid_for_network(Network::Testnet4)); + assert!(testnet_code.is_valid_for_network(Network::Signet)); + assert!(!testnet_code.is_valid_for_network(Network::Bitcoin)); + assert!(!testnet_code.is_valid_for_network(Network::Regtest)); + + let regtest_code = SilentPaymentCode::new(REGTEST_CODE.to_string()).unwrap(); + assert_eq!(regtest_code.to_string(), REGTEST_CODE); + assert!(regtest_code.is_valid_for_network(Network::Regtest)); + assert!(!regtest_code.is_valid_for_network(Network::Testnet)); + + assert!(matches!( + SilentPaymentCode::new("not-a-silent-payment-code".to_string()), + Err(SilentPaymentCodeParseError::Bech32 { .. }) + )); + assert!(matches!( + SilentPaymentCode::new("sp10ajr90".to_string()), + Err(SilentPaymentCodeParseError::Version { .. }) + )); +} + +#[test] +fn finish_and_sign_silent_payments_derives_spendable_outputs() { + const EXTERNAL_DESCRIPTOR: &str = "wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/84h/1h/1h/0/*)"; + const INTERNAL_DESCRIPTOR: &str = "wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/84h/1h/1h/1/*)"; + const SCAN_WIF: &str = "cTiSJ8p2zpGSkWGkvYFWfKurgWvSi9hdvzw9GEws18kS2VRPNS24"; + const SPEND_WIF: &str = "cRFcZbp7cAeZGsnYKdgSZwH6drJ3XLnPSGcjLNCpRy28tpGtZR11"; + + let wallet = Arc::new( + Wallet::new( + Arc::new(Descriptor::new(EXTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Arc::new(Descriptor::new(INTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Network::Regtest, + Arc::new(Persister::new_in_memory().unwrap()), + 25, + ) + .unwrap(), + ); + let funding_script = wallet + .reveal_next_address(KeychainKind::External) + .address + .script_pubkey() + .0 + .clone(); + let funding_output = BdkTxOut { + value: BdkAmount::from_sat(100_000), + script_pubkey: funding_script, + }; + let funding_transaction = BdkTransaction { + version: Version::TWO, + lock_time: LockTime::ZERO, + input: vec![BdkTxIn { + previous_output: BdkOutPoint::new(BdkTxid::all_zeros(), 0), + script_sig: Default::default(), + sequence: Sequence::MAX, + witness: Witness::default(), + }], + output: vec![funding_output.clone()], + }; + wallet.apply_unconfirmed_txs(vec![UnconfirmedTx { + tx: Arc::new(Transaction::from(funding_transaction)), + last_seen: 1, + }]); + + let code = Arc::new(SilentPaymentCode::new(REGTEST_CODE.to_string()).unwrap()); + let transaction = TxBuilder::new() + .fee_absolute(Arc::new(Amount::from_sat(500))) + .finish_and_sign_silent_payments( + &wallet, + vec![ + SilentPaymentRecipient { + code: Arc::clone(&code), + amount: Arc::new(Amount::from_sat(40_000)), + }, + SilentPaymentRecipient { + code: Arc::clone(&code), + amount: Arc::new(Amount::from_sat(20_000)), + }, + ], + ) + .unwrap(); + let transaction: BdkTransaction = transaction.as_ref().into(); + + assert_eq!(transaction.input.len(), 1); + assert_eq!( + transaction.input[0].sequence, + Sequence::ENABLE_LOCKTIME_NO_RBF + ); + let witness = &transaction.input[0].witness; + assert_eq!(witness.len(), 2); + let signature = ecdsa::Signature::from_slice(witness.nth(0).unwrap()).unwrap(); + let public_key = CompressedPublicKey::from_slice(witness.nth(1).unwrap()).unwrap(); + assert_eq!( + ScriptBuf::new_p2wpkh(&public_key.wpubkey_hash()), + funding_output.script_pubkey + ); + let sighash = SighashCache::new(&transaction) + .p2wpkh_signature_hash( + 0, + &funding_output.script_pubkey, + funding_output.value, + signature.sighash_type, + ) + .unwrap(); + let message = bdk_wallet::bitcoin::secp256k1::Message::from(sighash); + public_key + .verify( + &bdk_wallet::bitcoin::secp256k1::Secp256k1::verification_only(), + &message, + &signature, + ) + .unwrap(); + assert!(transaction + .output + .iter() + .all(|output| output.script_pubkey != code.0.get_placeholder_p2tr_spk())); + + let secp = bdk_wallet::bitcoin::secp256k1::Secp256k1::new(); + let scan_secret = PrivateKey::from_wif(SCAN_WIF).unwrap().inner; + let spend_secret = PrivateKey::from_wif(SPEND_WIF).unwrap().inner; + let scanner = Scanner::new(scan_secret, code.0.spend, BTreeMap::new()); + let found_outputs = scanner.scan_tx(&transaction, &[funding_output]).unwrap(); + + assert_eq!(found_outputs.len(), 2); + let mut found_amounts = found_outputs + .iter() + .map(|output| output.amount.to_sat()) + .collect::>(); + found_amounts.sort_unstable(); + assert_eq!(found_amounts, vec![20_000, 40_000]); + assert_ne!( + found_outputs[0].script_pubkey, + found_outputs[1].script_pubkey + ); + + for found_output in found_outputs { + assert!(transaction + .output + .iter() + .any(|output| output.script_pubkey == found_output.script_pubkey)); + + let output_secret = spend_secret.add_tweak(&found_output.tweak.into()).unwrap(); + let output_public_key = + XOnlyPublicKey::from_slice(&found_output.script_pubkey.as_bytes()[2..]).unwrap(); + assert_eq!(output_secret.x_only_public_key(&secp).0, output_public_key); + } +} + +#[test] +fn finish_and_sign_silent_payments_with_p2tr_input_derives_spendable_output() { + const EXTERNAL_DESCRIPTOR: &str = "tr(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/86h/1h/1h/0/*)"; + const INTERNAL_DESCRIPTOR: &str = "tr(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/86h/1h/1h/1/*)"; + const SCAN_WIF: &str = "cTiSJ8p2zpGSkWGkvYFWfKurgWvSi9hdvzw9GEws18kS2VRPNS24"; + const SPEND_WIF: &str = "cRFcZbp7cAeZGsnYKdgSZwH6drJ3XLnPSGcjLNCpRy28tpGtZR11"; + + let wallet = Arc::new( + Wallet::new( + Arc::new(Descriptor::new(EXTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Arc::new(Descriptor::new(INTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Network::Regtest, + Arc::new(Persister::new_in_memory().unwrap()), + 25, + ) + .unwrap(), + ); + let funding_script = wallet + .reveal_next_address(KeychainKind::External) + .address + .script_pubkey() + .0 + .clone(); + let funding_output = BdkTxOut { + value: BdkAmount::from_sat(100_000), + script_pubkey: funding_script, + }; + let funding_transaction = BdkTransaction { + version: Version::TWO, + lock_time: LockTime::ZERO, + input: vec![BdkTxIn { + previous_output: BdkOutPoint::new(BdkTxid::all_zeros(), 0), + script_sig: Default::default(), + sequence: Sequence::MAX, + witness: Witness::default(), + }], + output: vec![funding_output.clone()], + }; + wallet.apply_unconfirmed_txs(vec![UnconfirmedTx { + tx: Arc::new(Transaction::from(funding_transaction)), + last_seen: 1, + }]); + + let code = Arc::new(SilentPaymentCode::new(REGTEST_CODE.to_string()).unwrap()); + let transaction = TxBuilder::new() + .fee_absolute(Arc::new(Amount::from_sat(500))) + .finish_and_sign_silent_payments( + &wallet, + vec![SilentPaymentRecipient { + code: Arc::clone(&code), + amount: Arc::new(Amount::from_sat(40_000)), + }], + ) + .unwrap(); + let transaction: BdkTransaction = transaction.as_ref().into(); + + assert_eq!(transaction.input.len(), 1); + let witness = &transaction.input[0].witness; + assert_eq!(witness.len(), 1); + let signature = + bdk_wallet::bitcoin::taproot::Signature::from_slice(witness.nth(0).unwrap()).unwrap(); + assert!(funding_output.script_pubkey.is_p2tr()); + let funding_public_key = + XOnlyPublicKey::from_slice(&funding_output.script_pubkey.as_bytes()[2..]).unwrap(); + let prevouts = [funding_output.clone()]; + let sighash = SighashCache::new(&transaction) + .taproot_key_spend_signature_hash( + 0, + &bdk_wallet::bitcoin::sighash::Prevouts::All(&prevouts), + signature.sighash_type, + ) + .unwrap(); + let message = bdk_wallet::bitcoin::secp256k1::Message::from(sighash); + let secp = bdk_wallet::bitcoin::secp256k1::Secp256k1::new(); + secp.verify_schnorr(&signature.signature, &message, &funding_public_key) + .unwrap(); + assert!(transaction + .output + .iter() + .all(|output| output.script_pubkey != code.0.get_placeholder_p2tr_spk())); + + let scan_secret = PrivateKey::from_wif(SCAN_WIF).unwrap().inner; + let spend_secret = PrivateKey::from_wif(SPEND_WIF).unwrap().inner; + let scanner = Scanner::new(scan_secret, code.0.spend, BTreeMap::new()); + let found_outputs = scanner.scan_tx(&transaction, &[funding_output]).unwrap(); + + assert_eq!(found_outputs.len(), 1); + assert_eq!(found_outputs[0].amount, BdkAmount::from_sat(40_000)); + assert!(transaction + .output + .iter() + .any(|output| output.script_pubkey == found_outputs[0].script_pubkey)); + + let output_secret = spend_secret + .add_tweak(&found_outputs[0].tweak.into()) + .unwrap(); + let output_public_key = + XOnlyPublicKey::from_slice(&found_outputs[0].script_pubkey.as_bytes()[2..]).unwrap(); + assert_eq!(output_secret.x_only_public_key(&secp).0, output_public_key); +} + +#[test] +fn finish_and_sign_silent_payments_rejects_p2sh_input() { + const EXTERNAL_DESCRIPTOR: &str = "sh(wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/49h/1h/1h/0/*))"; + const INTERNAL_DESCRIPTOR: &str = "sh(wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/49h/1h/1h/1/*))"; + + let wallet = Arc::new( + Wallet::new( + Arc::new(Descriptor::new(EXTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Arc::new(Descriptor::new(INTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Network::Regtest, + Arc::new(Persister::new_in_memory().unwrap()), + 25, + ) + .unwrap(), + ); + let funding_script = wallet + .reveal_next_address(KeychainKind::External) + .address + .script_pubkey() + .0 + .clone(); + assert!(funding_script.is_p2sh()); + let funding_transaction = BdkTransaction { + version: Version::TWO, + lock_time: LockTime::ZERO, + input: vec![BdkTxIn { + previous_output: BdkOutPoint::new(BdkTxid::all_zeros(), 0), + script_sig: Default::default(), + sequence: Sequence::MAX, + witness: Witness::default(), + }], + output: vec![BdkTxOut { + value: BdkAmount::from_sat(100_000), + script_pubkey: funding_script, + }], + }; + wallet.apply_unconfirmed_txs(vec![UnconfirmedTx { + tx: Arc::new(Transaction::from(funding_transaction)), + last_seen: 1, + }]); + + let code = Arc::new(SilentPaymentCode::new(REGTEST_CODE.to_string()).unwrap()); + assert!(matches!( + TxBuilder::new() + .fee_absolute(Arc::new(Amount::from_sat(500))) + .finish_and_sign_silent_payments( + &wallet, + vec![SilentPaymentRecipient { + code, + amount: Arc::new(Amount::from_sat(40_000)), + }], + ), + Err(SilentPaymentSendError::P2shInputsUnsupported) + )); +} + +#[test] +fn finish_and_sign_silent_payments_rejects_unsupported_configuration() { + const EXTERNAL_DESCRIPTOR: &str = "wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/84h/1h/1h/0/*)"; + const INTERNAL_DESCRIPTOR: &str = "wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/84h/1h/1h/1/*)"; + + let wallet = Arc::new( + Wallet::new( + Arc::new(Descriptor::new(EXTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Arc::new(Descriptor::new(INTERNAL_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap()), + Network::Regtest, + Arc::new(Persister::new_in_memory().unwrap()), + 25, + ) + .unwrap(), + ); + let code = Arc::new(SilentPaymentCode::new(TSP_CODE.to_string()).unwrap()); + + assert!(matches!( + TxBuilder::new().finish_and_sign_silent_payments( + &wallet, + vec![SilentPaymentRecipient { + code, + amount: Arc::new(Amount::from_sat(40_000)), + }], + ), + Err(SilentPaymentSendError::NetworkMismatch { .. }) + )); + + let code = Arc::new(SilentPaymentCode::new(REGTEST_CODE.to_string()).unwrap()); + let amount = Arc::new(Amount::from_sat(1)); + let recipients = (0..2324) + .map(|_| SilentPaymentRecipient { + code: Arc::clone(&code), + amount: Arc::clone(&amount), + }) + .collect(); + assert!(matches!( + TxBuilder::new().finish_and_sign_silent_payments(&wallet, recipients), + Err(SilentPaymentSendError::RecipientLimitExceeded) + )); + + assert!(matches!( + TxBuilder::new() + .set_exact_sequence(Sequence::ENABLE_RBF_NO_LOCKTIME.to_consensus_u32()) + .finish_and_sign_silent_payments( + &wallet, + vec![SilentPaymentRecipient { + code: Arc::clone(&code), + amount: Arc::new(Amount::from_sat(40_000)), + }], + ), + Err(SilentPaymentSendError::RbfUnsupported) + )); + + assert!(matches!( + TxBuilder::new() + .only_witness_utxo() + .finish_and_sign_silent_payments( + &wallet, + vec![SilentPaymentRecipient { + code, + amount: Arc::new(Amount::from_sat(40_000)), + }], + ), + Err(SilentPaymentSendError::OnlyWitnessUtxoUnsupported) + )); +} diff --git a/bdk-ffi/src/tx_builder.rs b/bdk-ffi/src/tx_builder.rs index c5e5a608..15e2fa87 100644 --- a/bdk-ffi/src/tx_builder.rs +++ b/bdk-ffi/src/tx_builder.rs @@ -1,8 +1,14 @@ +#[cfg(feature = "experimental-silent-payments")] +use crate::bitcoin::Transaction; use crate::bitcoin::{Amount, FeeRate, Input, OutPoint, Psbt, Script, Txid}; use crate::error::{AddForeignUtxoError, CreateTxError, SighashParseError}; +#[cfg(feature = "experimental-silent-payments")] +use crate::silent_payments::{SilentPaymentRecipient, SilentPaymentSendError}; use crate::types::{KeychainKind, LockTime, ScriptAmount}; use crate::wallet::Wallet; +#[cfg(feature = "experimental-silent-payments")] +use bdk_sp::send::psbt::derive_sp; use bdk_wallet::bitcoin::absolute::LockTime as BdkLockTime; use bdk_wallet::bitcoin::amount::Amount as BdkAmount; use bdk_wallet::bitcoin::psbt::Input as BdkInput; @@ -17,6 +23,11 @@ use bdk_wallet::coin_selection::{ OldestFirstCoinSelection as BdkOldestFirstCoinSelection, SingleRandomDraw as BdkSingleRandomDraw, }; +#[cfg(feature = "experimental-silent-payments")] +use bdk_wallet::miniscript::descriptor::KeyMapWrapper; +#[cfg(feature = "experimental-silent-payments")] +#[allow(deprecated)] +use bdk_wallet::signer::SignOptions as BdkSignOptions; use bdk_wallet::TxOrdering as BdkTxOrdering; use std::collections::BTreeMap; @@ -27,6 +38,9 @@ use std::sync::Arc; type ChangeSpendPolicy = bdk_wallet::ChangeSpendPolicy; +#[cfg(feature = "experimental-silent-payments")] +const MAX_SILENT_PAYMENT_RECIPIENTS_PER_SCAN_KEY: usize = 2323; + /// A `TxBuilder` is created by calling `build_tx` on a wallet. After assigning it, you set options on it until finally /// calling `finish` to consume the builder and generate the transaction. #[derive(Clone, uniffi::Object)] @@ -585,6 +599,183 @@ impl TxBuilder { } } +#[cfg(feature = "experimental-silent-payments")] +#[uniffi::export] +impl TxBuilder { + /// Builds and signs a BIP 352 silent payment transaction. + /// + /// This experimental method doesn't allow multi-party derivation, as the wallet must have + /// software descriptor keys for all inputs available for shared secret derivation. + /// Transactions created by this method don't opt in to replace-by-fee. + /// + /// WARNING: To avoid change address reuse you must persist the changes resulting from one or + /// more calls to this method before closing the wallet. See `Wallet::reveal_next_address`. + pub fn finish_and_sign_silent_payments( + &self, + wallet: &Arc, + recipients: Vec, + ) -> Result, SilentPaymentSendError> { + if recipients.is_empty() { + return Err(SilentPaymentSendError::NoRecipients); + } + let mut recipient_counts = HashMap::new(); + for recipient in &recipients { + let count = recipient_counts.entry(recipient.code.0.scan).or_insert(0); + *count += 1; + if *count > MAX_SILENT_PAYMENT_RECIPIENTS_PER_SCAN_KEY { + return Err(SilentPaymentSendError::RecipientLimitExceeded); + } + } + if !self.foreign_utxos.is_empty() { + return Err(SilentPaymentSendError::ForeignInputsUnsupported); + } + if self.only_witness_utxo { + return Err(SilentPaymentSendError::OnlyWitnessUtxoUnsupported); + } + if self + .sighash + .is_some_and(|sighash| !matches!(sighash.to_u32(), 0 | 1)) + { + return Err(SilentPaymentSendError::UnsupportedSighash); + } + let sequence = self + .sequence + .map(Sequence) + .unwrap_or(Sequence::ENABLE_LOCKTIME_NO_RBF); + if sequence.is_rbf() { + return Err(SilentPaymentSendError::RbfUnsupported); + } + + let mut wallet = wallet.get_wallet(); + let wallet_network = wallet.network(); + let mut silent_payment_builder = Self { + sequence: Some(sequence.to_consensus_u32()), + ..self.clone() + }; + let mut payment_codes = Vec::with_capacity(recipients.len()); + let mut placeholder_scripts = Vec::with_capacity(recipients.len()); + + for recipient in recipients { + if !recipient.code.is_valid_for_network(wallet_network) { + return Err(SilentPaymentSendError::NetworkMismatch { + code: recipient.code.to_string(), + wallet_network: wallet_network.to_string(), + }); + } + + let payment_code = recipient.code.0.clone(); + let placeholder_script = payment_code.get_placeholder_p2tr_spk(); + silent_payment_builder + .recipients + .push((placeholder_script.clone(), recipient.amount.0)); + payment_codes.push(payment_code); + placeholder_scripts.push(placeholder_script); + } + + let tx_builder = wallet.build_tx(); + let psbt = match silent_payment_builder.coin_selection { + None | Some(CoinSelectionAlgorithm::BranchAndBound) => { + silent_payment_builder.finish_with_builder(tx_builder) + } + Some(CoinSelectionAlgorithm::LargestFirst) => silent_payment_builder + .finish_with_builder(tx_builder.coin_selection(BdkLargestFirstCoinSelection)), + Some(CoinSelectionAlgorithm::OldestFirst) => silent_payment_builder + .finish_with_builder(tx_builder.coin_selection(BdkOldestFirstCoinSelection)), + Some(CoinSelectionAlgorithm::SingleRandomDraw) => silent_payment_builder + .finish_with_builder(tx_builder.coin_selection(BdkSingleRandomDraw)), + } + .map_err(|error| SilentPaymentSendError::CreateTransaction { + error_message: error.to_string(), + })?; + + let mut psbt = psbt.0.lock().unwrap().clone(); + if psbt + .iter_funding_utxos() + .any(|utxo| utxo.is_ok_and(|utxo| utxo.script_pubkey.is_p2sh())) + { + return Err(SilentPaymentSendError::P2shInputsUnsupported); + } + + let placeholder_outputs = psbt + .unsigned_tx + .output + .iter() + .enumerate() + .filter_map(|(index, output)| { + placeholder_scripts + .contains(&output.script_pubkey) + .then_some((index, output.script_pubkey.clone())) + }) + .collect::>(); + if placeholder_outputs.len() != placeholder_scripts.len() { + return Err(SilentPaymentSendError::PlaceholderOutputMismatch { + expected: placeholder_scripts.len() as u64, + actual: placeholder_outputs.len() as u64, + }); + } + + let original_inputs = psbt.inputs.clone(); + let sign_options = BdkSignOptions::default(); + + let finalized = wallet + .sign(&mut psbt, sign_options.clone()) + .map_err(|error| SilentPaymentSendError::InitialSigning { + error_message: error.to_string(), + })?; + if !finalized { + return Err(SilentPaymentSendError::InitialSigningIncomplete); + } + + for (original_input, input) in original_inputs.iter().zip(psbt.inputs.iter_mut()) { + let final_script_sig = input.final_script_sig.take(); + let final_script_witness = input.final_script_witness.take(); + *input = original_input.clone(); + input.final_script_sig = final_script_sig; + input.final_script_witness = final_script_witness; + } + + let secp = wallet.secp_ctx(); + let mut key_map = wallet.get_signers(KeychainKind::External).as_key_map(secp); + key_map.extend(wallet.get_signers(KeychainKind::Internal).as_key_map(secp)); + let key_provider = KeyMapWrapper::from(key_map); + + derive_sp(&mut psbt, &key_provider, &payment_codes, secp) + .map_err(SilentPaymentSendError::from)?; + + let placeholder_remains = placeholder_outputs.iter().any(|(index, placeholder)| { + psbt.unsigned_tx.output[*index].script_pubkey == *placeholder + }); + if placeholder_remains { + return Err(SilentPaymentSendError::PlaceholderNotReplaced); + } + + for input in &mut psbt.inputs { + input.final_script_sig = None; + input.final_script_witness = None; + input.partial_sigs.clear(); + input.tap_key_sig = None; + input.tap_script_sigs.clear(); + } + + let finalized = wallet.sign(&mut psbt, sign_options).map_err(|error| { + SilentPaymentSendError::FinalSigning { + error_message: error.to_string(), + } + })?; + if !finalized { + return Err(SilentPaymentSendError::FinalSigningIncomplete); + } + + let transaction = + psbt.extract_tx() + .map_err(|error| SilentPaymentSendError::ExtractTransaction { + error_message: error.to_string(), + })?; + + Ok(Arc::new(transaction.into())) + } +} + impl TxBuilder { fn finish_with_builder( &self,