From bd9a33e0e175a9a98d04bf7e9570af17017b6f8c Mon Sep 17 00:00:00 2001 From: itorod Date: Thu, 12 Nov 2026 14:36:00 -0500 Subject: [PATCH 1/2] feat: Add sign method for psbt --- .../kotlin/org/bitcoindevkit/PsbtTest.kt | 83 +++++++++++ bdk-ffi/src/bitcoin.rs | 79 ++++++++++- bdk-ffi/src/error.rs | 74 ++++++++++ bdk-ffi/src/tests/bitcoin.rs | 130 +++++++++++++++++- 4 files changed, 361 insertions(+), 5 deletions(-) create mode 100644 bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt diff --git a/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt b/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt new file mode 100644 index 00000000..ab0bb90d --- /dev/null +++ b/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt @@ -0,0 +1,83 @@ +package org.bitcoindevkit + + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue +import kotlin.test.assertFalse +import androidx.test.ext.junit.runners.AndroidJUnit4 +import kotlinx.coroutines.delay +import kotlinx.coroutines.runBlocking +import org.junit.runner.RunWith +import org.kotlinbitcointools.regtesttoolbox.regenv.RegEnv +import kotlin.time.Duration.Companion.milliseconds + +@RunWith(AndroidJUnit4::class) +class PsbtTest { + val conn: Persister = Persister.newInMemory() + + @Test + fun signTaprootPsbt() { + runBlocking { + val regtestEnv = RegEnv.connectTo( + host = "10.0.2.2", + walletName = "faucet", + username = "regtest", + password = "password", + ) + + val wallet: Wallet = Wallet( + descriptor = BIP86_DESCRIPTOR, + changeDescriptor = BIP86_CHANGE_DESCRIPTOR, + network = Network.REGTEST, + persister = conn + ) + val newAddress = wallet.revealNextAddress(KeychainKind.EXTERNAL).address + + val txidString = regtestEnv.send(newAddress.toString(), 0.12345678, 2.0) + regtestEnv.mine(2) + + val esploraClient = EsploraClient(ESPLORA_REGTEST_URL) + val txid = Txid.fromString(txidString) + // Wait for the Esplora client to see the transaction. Try 5x per second for 20 seconds. + for (i in 0..99) { + if (esploraClient.getTx(txid) != null) break + delay(200.milliseconds) + } + + val fullScanRequest: FullScanRequest = wallet.startFullScan().build() + val update = esploraClient.fullScan(fullScanRequest, 10uL, 1uL) + + wallet.applyUpdate(update) + wallet.persist(conn) + + val balance = wallet.balance().total.toSat() + + val recipient: Address = Address("bcrt1q645m0j78v9pajdfp0g0w6wacl4v8s7mvrwsjx5", Network.REGTEST) + + val psbt: Psbt = TxBuilder() + .addRecipient(recipient.scriptPubkey(), Amount.fromSat(4420uL)) + .feeRate(FeeRate.fromSatPerVb(22uL)) + .finish(wallet) + + val psbtSignedResult = psbt.sign(listOf(BIP86_DESCRIPTOR)) + + assertTrue( + psbtSignedResult.errors.isEmpty(), + "Signing failed with errors: ${psbtSignedResult.errors}" + ) + assertTrue(psbtSignedResult.signedInputs.isNotEmpty(), "At least one input should be signed") + + val inputs = psbt.input() + val tapKeySig = inputs[0].tapKeySig + + assertTrue(tapKeySig != null, "tapKeySig should not be null after signing the PSBT input") + + val finalized = psbt.finalize() + assertTrue( + finalized.couldFinalize, + "PSBT should finalize successfully, errors: ${finalized.errors}" + ) + } + } +} diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs index 9d29eb07..bd7a4755 100644 --- a/bdk-ffi/src/bitcoin.rs +++ b/bdk-ffi/src/bitcoin.rs @@ -1,6 +1,6 @@ use crate::error::{ AddressParseError, Bip32Error, ExtractTxError, FeeRateError, FromScriptError, HashParseError, - PsbtError, PsbtParseError, TransactionError, + PsbtError, PsbtParseError, PsbtSignError, TransactionError, }; use crate::error::{ParseAmountError, PsbtFinalizeError}; use crate::keys::DerivationPath; @@ -18,6 +18,7 @@ use bdk_wallet::bitcoin::hashes::sha256::Hash as BitcoinSha256Hash; use bdk_wallet::bitcoin::hashes::sha256d::Hash as BitcoinDoubleSha256Hash; use bdk_wallet::bitcoin::psbt::Input as BdkInput; use bdk_wallet::bitcoin::psbt::Output as BdkOutput; +use bdk_wallet::bitcoin::psbt::SigningKeys as BdkSigningKeys; use bdk_wallet::bitcoin::secp256k1::Secp256k1; use bdk_wallet::bitcoin::taproot::LeafNode as BdkLeafNode; use bdk_wallet::bitcoin::taproot::NodeInfo as BdkNodeInfo; @@ -37,7 +38,8 @@ use bdk_wallet::bitcoin::Wtxid as BitcoinWtxid; use bdk_wallet::miniscript::psbt::PsbtExt; use bdk_wallet::serde_json; -use std::collections::HashMap; +use crate::descriptor::Descriptor; +use std::collections::{BTreeSet, HashMap}; use std::convert::TryFrom; use std::fmt::Display; use std::fs::File; @@ -1579,6 +1581,60 @@ impl Psbt { let psbt = self.0.lock().unwrap(); psbt.outputs.iter().map(|o| o.into()).collect() } + + /// Signs the inputs of this PSBT using the secret keys held by the given descriptors. + /// + /// Pass every descriptor that may own inputs of this transaction (for example a wallet's + /// external and internal descriptors). Each descriptor is tried against every input, and keys + /// that do not match an input are ignored. This function does not support scripts that contain + /// `OP_CODESEPARATOR`. + /// + /// # Returns + /// + /// A `PsbtSignResult` listing the inputs that received a signature in this call and the errors + /// encountered while attempting to sign. An empty `signed_inputs` means nothing was signed, for + /// example because the descriptors do not match the inputs. Use `finalize` to check whether the + /// PSBT is complete. + /// + /// # Errors + /// + /// Returns `SignError::NoSecretKeys` if none of the descriptors contain secret keys. + pub fn sign(&self, descriptors: Vec>) -> Result { + if descriptors.iter().all(|d| d.key_map.is_empty()) { + return Err(PsbtSignError::NoSecretKeys); + } + + let mut psbt = self.0.lock().unwrap(); + let secp = Secp256k1::new(); + let mut signed_inputs = BTreeSet::new(); + let mut errors = HashMap::new(); + + for descriptor in descriptors.iter().filter(|d| !d.key_map.is_empty()) { + let keys = + bdk_wallet::miniscript::descriptor::KeyMapWrapper::from(descriptor.key_map.clone()); + let (used, errs) = match psbt.sign(&keys, &secp) { + Ok(used) => (used, Default::default()), + Err((used, errs)) => (used, errs), + }; + signed_inputs.extend( + used.into_iter() + .filter(|(_, keys)| match keys { + BdkSigningKeys::Ecdsa(k) => !k.is_empty(), + BdkSigningKeys::Schnorr(k) => !k.is_empty(), + }) + .map(|(index, _)| index as u64), + ); + errors.extend( + errs.into_iter() + .map(|(index, error)| (index as u64, PsbtSignError::from(error))), + ); + } + + Ok(PsbtSignResult { + signed_inputs: signed_inputs.into_iter().collect(), + errors, + }) + } } impl From for Psbt { @@ -1669,6 +1725,25 @@ impl From for BdkTxOut { } } +#[derive(uniffi::Record)] +#[uniffi::export(Display)] +pub struct PsbtSignResult { + /// Inputs that received at least one signature in this call. + pub signed_inputs: Vec, + /// Errors encountered while attempting to sign, keyed by input index. + pub errors: HashMap, +} + +impl Display for PsbtSignResult { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "Signed inputs: {:?}, Errors: {:?}", + self.signed_inputs, self.errors + ) + } +} + /// A child number in a derivation path #[derive(Copy, Clone, uniffi::Enum)] pub enum ChildNumber { diff --git a/bdk-ffi/src/error.rs b/bdk-ffi/src/error.rs index 945c8ee7..a6eeac6d 100644 --- a/bdk-ffi/src/error.rs +++ b/bdk-ffi/src/error.rs @@ -13,6 +13,7 @@ use bdk_wallet::bitcoin::hex::DisplayHex; use bdk_wallet::bitcoin::psbt::Error as BdkPsbtError; use bdk_wallet::bitcoin::psbt::ExtractTxError as BdkExtractTxError; use bdk_wallet::bitcoin::psbt::PsbtParseError as BdkPsbtParseError; +use bdk_wallet::bitcoin::psbt::SignError as BdkSignError; use bdk_wallet::bitcoin::script::PushBytesError; use bdk_wallet::chain::local_chain::CannotConnectError as BdkCannotConnectError; use bdk_wallet::chain::rusqlite::Error as BdkSqliteError; @@ -868,6 +869,79 @@ pub enum SignerError { Psbt { error_message: String }, } +#[derive(Debug, thiserror::Error, uniffi::Error)] +#[uniffi::export(Debug, Display)] +pub enum PsbtSignError { + #[error("index out of bounds {error_message}")] + IndexOutOfBounds { error_message: String }, + #[error("invalid sighash type")] + InvalidSighashType, + #[error("missing input utxo")] + MissingInputUtxo, + #[error("missing redeem script")] + MissingRedeemScript, + #[error("missing spending utxo")] + MissingSpendUtxo, + #[error("missing witness script")] + MissingWitnessScript, + #[error("signing algorithm and key type does not match")] + MismatchedAlgoKey, + #[error("attempted to ECDSA sign a non-ECDSA input")] + NotEcdsa, + #[error("the scriptPubkey is not a P2WPKH script")] + NotWpkh, + #[error("sighash computation error (segwit v0 input): {error_message}")] + SegwitV0Sighash { error_message: String }, + #[error("sighash computation error (p2wpkh input): {error_message}")] + P2wpkhSighash { error_message: String }, + #[error("sighash computation error (taproot input): {error_message}")] + TaprootError { error_message: String }, + #[error("unable to determine the output type")] + UnknownOutputType, + #[error("unable to find key")] + KeyNotFound, + #[error("attempt to sign an input with the wrong signing algorithm")] + WrongSigningAlgorithm, + #[error("signing request currently unsupported")] + Unsupported, + #[error("none of the provided descriptors contain secret keys")] + NoSecretKeys, + #[error("unknown signing error")] + Unknown, +} + +impl From for PsbtSignError { + fn from(error: BdkSignError) -> Self { + match error { + BdkSignError::IndexOutOfBounds(e) => Self::IndexOutOfBounds { + error_message: e.to_string(), + }, + BdkSignError::InvalidSighashType => Self::InvalidSighashType, + BdkSignError::MissingInputUtxo => Self::MissingInputUtxo, + BdkSignError::MissingRedeemScript => Self::MissingRedeemScript, + BdkSignError::MissingSpendUtxo => Self::MissingSpendUtxo, + BdkSignError::MissingWitnessScript => Self::MissingWitnessScript, + BdkSignError::MismatchedAlgoKey => Self::MismatchedAlgoKey, + BdkSignError::NotEcdsa => Self::NotEcdsa, + BdkSignError::NotWpkh => Self::NotWpkh, + BdkSignError::SegwitV0Sighash(e) => Self::SegwitV0Sighash { + error_message: e.to_string(), + }, + BdkSignError::P2wpkhSighash(e) => Self::P2wpkhSighash { + error_message: e.to_string(), + }, + BdkSignError::TaprootError(e) => Self::TaprootError { + error_message: e.to_string(), + }, + BdkSignError::UnknownOutputType => Self::UnknownOutputType, + BdkSignError::KeyNotFound => Self::KeyNotFound, + BdkSignError::WrongSigningAlgorithm => Self::WrongSigningAlgorithm, + BdkSignError::Unsupported => Self::Unsupported, + _ => Self::Unknown, // Catch all for any other errors not explicitly handled. Satisfies non-exhaustive. + } + } +} + #[derive(Debug, thiserror::Error, uniffi::Error)] #[uniffi::export(Debug, Display)] pub enum TransactionError { diff --git a/bdk-ffi/src/tests/bitcoin.rs b/bdk-ffi/src/tests/bitcoin.rs index d22de687..6bcc0881 100644 --- a/bdk-ffi/src/tests/bitcoin.rs +++ b/bdk-ffi/src/tests/bitcoin.rs @@ -1,8 +1,9 @@ use crate::bitcoin::{ - Address, AddressData, ControlBlock, FeeRate, Input, Key, Network, ProprietaryKey, Psbt, Script, - TapScriptEntry, Transaction, + Address, AddressData, ControlBlock, FeeRate, Input, Key, Network, NetworkKind, ProprietaryKey, + Psbt, Script, TapScriptEntry, Transaction, }; -use crate::error::{AddForeignUtxoError, TransactionError}; +use crate::descriptor::Descriptor; +use crate::error::{AddForeignUtxoError, PsbtSignError, TransactionError}; use bdk_electrum::bdk_core::bitcoin::hex::DisplayHex; use bdk_wallet::bitcoin::psbt::Input as BdkInput; use std::collections::HashMap; @@ -722,6 +723,129 @@ fn test_psbt_output_tap_tree() { ); } +#[test] +fn test_psbt_sign_account_xprv() { + // A PSBT with a single Taproot key-path input to be signed. + let psbt = Psbt::new( + "cHNidP8BAF4CAAAAAU1jsXk14vinaw/FavxEf6I13DTTWcQ3W3qfEO45TulmAAAAAAD/////ASgjAAAAAAAAIlEgXnzxN1lKw2Se0nelATBRTNfinxJWqjQNKLqvwkspeREAAAAAAAEBKxAnAAAAAAAAIlEgXnzxN1lKw2Se0nelATBRTNfinxJWqjQNKLqvwkspeREhFtXKImYR1dqFkU+0ktlTKKLzI4vHT1o4Ukyt7xYanJ5zGQBRWcFzVgAAgAEAAIAAAACAAAAAAAAAAAABFyDVyiJmEdXahZFPtJLZUyii8yOLx09aOFJMre8WGpyecwAA" + .to_string(), + ) + .unwrap(); + + // The descriptor holding the secret key corresponding to the input above. + let descriptor = Descriptor::new( + "tr([5159c173/86h/1h/0h]tprv8gfBCLYgHZLJLhg1DUSY6NN6eNAee3aqt3SE3M1hywpAiFWYGsm6U6B17VDKh8W1SQnatRpZujU5xseJ84nYZmkxPGCngNhmBMVRY2sAZhY/0/*)".to_string(), + NetworkKind::Test, + ) + .unwrap(); + + // Before signing there is no signature for the input. + assert!(psbt.input()[0].tap_key_sig.is_none()); + + let sign_result = psbt.sign(vec![Arc::new(descriptor)]).unwrap(); + + // Exactly one input was signed and there were no signing errors. + assert!(sign_result.errors.is_empty()); + assert_eq!(sign_result.signed_inputs, vec![0]); + + // After signing the input carries a Taproot key-spend signature. + assert!(psbt.input()[0].tap_key_sig.is_some()); + + let finalized = psbt.finalize(); + assert!( + finalized.could_finalize, + "account-xprv signature should be valid and allow finalization: {:?}", + finalized.errors + ); +} + +/// Verifies that a master xprv can sign and finalize a Taproot key-path PSBT. +#[test] +fn test_psbt_sign_master_xprv() { + let psbt = Psbt::new( + "cHNidP8BAIkCAAAAAd7Z58uNWmI7QC42edMCsKVfKMy72i68/bT+AzZDlfGWAAAAAAD9////AjUBAQAAAAAAIlEgbor4TTTaKr/DR4vQbGW6FHCQYnjuq0UpNplr8IFEUmgQJwAAAAAAACJRIAibNvaCqBgrW+quV/ypDHIA8Saao97/JxGenDgaZTKPAAAAAAABASvgKAEAAAAAACJRIFGvNAV+rp6xsnJxkEp4563vQ6BioBxl6P93UYjQGA/6IRYj8800YYG7nOzss1f693txGJD9kHZEbDvrlc2kaCSSCxkAkSLZ4FYAAIABAACAAAAAgAAAAAAAAAAAARcgI/PNNGGBu5zs7LNX+vd7cRiQ/ZB2RGw765XNpGgkkgsAAQUgSdyW+m8C7riSF8PKZxCBg2lU3xqZoUe6tTu9rJmBXDghB0nclvpvAu64khfDymcQgYNpVN8amaFHurU7vayZgVw4GQCRItngVgAAgAEAAIAAAACAAQAAAAAAAAAAAQUgmEUFEs04MftraM+doth9Q9GDpsmEp87kv/5tyvunoHIhB5hFBRLNODH7a2jPnaLYfUPRg6bJhKfO5L/+bcr7p6ByGQCRItngVgAAgAEAAIAAAACAAAAAAAEAAAAA" + .to_string(), + ) + .unwrap(); + + const MASTER: &str = "tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B"; + let descriptor = + Descriptor::new(format!("tr({MASTER}/86h/1h/0h/0/*)"), NetworkKind::Test).unwrap(); + let sign_result = psbt.sign(vec![Arc::new(descriptor)]).unwrap(); + assert!(sign_result.errors.is_empty()); + assert_eq!(sign_result.signed_inputs, vec![0]); + assert!(psbt.input()[0].tap_key_sig.is_some()); + + let finalized = psbt.finalize(); + assert!( + finalized.could_finalize, + "master-xprv PSBT should finalize: {:?}", + finalized.errors + ); +} + +const SIGN_TEST_PSBT: &str = "cHNidP8BAF4CAAAAAU1jsXk14vinaw/FavxEf6I13DTTWcQ3W3qfEO45TulmAAAAAAD/////ASgjAAAAAAAAIlEgXnzxN1lKw2Se0nelATBRTNfinxJWqjQNKLqvwkspeREAAAAAAAEBKxAnAAAAAAAAIlEgXnzxN1lKw2Se0nelATBRTNfinxJWqjQNKLqvwkspeREhFtXKImYR1dqFkU+0ktlTKKLzI4vHT1o4Ukyt7xYanJ5zGQBRWcFzVgAAgAEAAIAAAACAAAAAAAAAAAABFyDVyiJmEdXahZFPtJLZUyii8yOLx09aOFJMre8WGpyecwAA"; +const SIGN_TEST_ACCOUNT_DESCRIPTOR: &str = "tr([5159c173/86h/1h/0h]tprv8gfBCLYgHZLJLhg1DUSY6NN6eNAee3aqt3SE3M1hywpAiFWYGsm6U6B17VDKh8W1SQnatRpZujU5xseJ84nYZmkxPGCngNhmBMVRY2sAZhY/0/*)"; +const UNRELATED_TPRV: &str = "tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B"; + +/// Descriptors that match no input sign nothing and report no errors. +#[test] +fn test_psbt_sign_non_matching_descriptor_signs_nothing() { + let psbt = Psbt::new(SIGN_TEST_PSBT.to_string()).unwrap(); + let wrong = Descriptor::new( + format!("wpkh({UNRELATED_TPRV}/84h/1h/0h/0/*)"), + NetworkKind::Test, + ) + .unwrap(); + + let sign_result = psbt.sign(vec![Arc::new(wrong)]).unwrap(); + assert!(sign_result.signed_inputs.is_empty()); + assert!(sign_result.errors.is_empty()); + assert!(psbt.input()[0].tap_key_sig.is_none()); +} + +/// A non-matching descriptor alongside a matching one does not prevent signing. +#[test] +fn test_psbt_sign_multiple_descriptors() { + let psbt = Psbt::new(SIGN_TEST_PSBT.to_string()).unwrap(); + let wrong = Descriptor::new( + format!("wpkh({UNRELATED_TPRV}/84h/1h/0h/0/*)"), + NetworkKind::Test, + ) + .unwrap(); + let matching = + Descriptor::new(SIGN_TEST_ACCOUNT_DESCRIPTOR.to_string(), NetworkKind::Test).unwrap(); + + let sign_result = psbt + .sign(vec![Arc::new(wrong), Arc::new(matching)]) + .unwrap(); + + assert_eq!(sign_result.signed_inputs, vec![0]); + assert!(sign_result.errors.is_empty()); + assert!(psbt.input()[0].tap_key_sig.is_some()); +} + +/// Signing without any secret keys is an error rather than an empty result. +#[test] +fn test_psbt_sign_without_secret_keys_errors() { + let psbt = Psbt::new(SIGN_TEST_PSBT.to_string()).unwrap(); + + assert!(matches!( + psbt.sign(vec![]), + Err(PsbtSignError::NoSecretKeys) + )); + + let public = Descriptor::new( + "tr(tpubD6NzVbkrYhZ4XgiXtGrdW5XDAPFCL9h7we1vwNCpn8tGbBcgfVYjXyhWo4E1xkh56hjod1RhGjxbaTLV3X4FyWuejifB9jusQ46QzG87VKp/0/*)".to_string(), + NetworkKind::Test, + ) + .unwrap(); + assert!(matches!( + psbt.sign(vec![Arc::new(public)]), + Err(PsbtSignError::NoSecretKeys) + )); +} + fn sample_psbt() -> Psbt { Psbt::new("cHNidP8BAH0CAAAAAXHl8cCbj84lm1v42e54IGI6CQru/nBXwrPE3q2fiGO4AAAAAAD9////Ar4DAAAAAAAAIgAgYw/rnGd4Bifj8s7TaMgR2tal/lq+L1jVv2Sqd1mxMbJEEQAAAAAAABYAFNVpt8vHYUPZNSF6Hu07uP1YeHts4QsAAAABALUCAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////BAJ+CwD/////AkAlAAAAAAAAIgAgQyrnn86L9D3vDiH959KJbPudDHc/bp6nI9E5EBLQD1YAAAAAAAAAACZqJKohqe3i9hw/cdHe/T+pmd+jaVN1XGkGiXmZYrSL69g2l06M+QEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQErQCUAAAAAAAAiACBDKuefzov0Pe8OIf3n0ols+50Mdz9unqcj0TkQEtAPViICAy4V+d/Qff71zzPXxK4FWG5x+wL/Ku93y/LG5p+0rI2xSDBFAiEA9b0OdASAs0P2uhQinjN7QGP5jX/b32LcShBmny8U0RUCIBebxvCDbpchCjqLAhOMjydT80DAzokaalGzV7XVTsbiASICA1tMY+46EgxIHU18bgHnUvAAlAkMq5LfwkpOGZ97sDKRRzBEAiBpmlZwJocNEiKLxexEX0Par6UgG8a89AklTG3/z9AHlAIgQH/ybCvfKJzr2dq0+IyueDebm7FamKIJdzBYWMXRr/wBIgID+aCzK9nclwhbbN7KbIVGUQGLWZsjcaqWPxk9gFeG+FxIMEUCIQDRPBzb0i9vaUmxCcs1yz8uq4tq1mdDAYvvYn3isKEhFAIgfmeTLLzMo0mmQ23ooMnyx6iPceE8xV5CvARuJsd88tEBAQVpUiEDW0xj7joSDEgdTXxuAedS8ACUCQyrkt/CSk4Zn3uwMpEhAy4V+d/Qff71zzPXxK4FWG5x+wL/Ku93y/LG5p+0rI2xIQP5oLMr2dyXCFts3spshUZRAYtZmyNxqpY/GT2AV4b4XFOuIgYDLhX539B9/vXPM9fErgVYbnH7Av8q73fL8sbmn7SsjbEYCapBE1QAAIABAACAAAAAgAAAAAAAAAAAIgYDW0xj7joSDEgdTXxuAedS8ACUCQyrkt/CSk4Zn3uwMpEY2bvrelQAAIABAACAAAAAgAAAAAAAAAAAIgYD+aCzK9nclwhbbN7KbIVGUQGLWZsjcaqWPxk9gFeG+FwYAKVFVFQAAIABAACAAAAAgAAAAAAAAAAAAAEBaVIhA7cr8fTHOPtE+t0zM3iWJvpfPvsNaVyQ0Sar6nIe9tQXIQMm7k7OY+q+Lsge3bVACuSa9r19Js+lNuTtEhehWkpe1iECelHmzmhzDsQTDnApIcnWRz3oFR68UX1ag8jfk/SKuopTriICAnpR5s5ocw7EEw5wKSHJ1kc96BUevFF9WoPI35P0irqKGAClRVRUAACAAQAAgAAAAIABAAAAAAAAACICAybuTs5j6r4uyB7dtUAK5Jr2vX0mz6U25O0SF6FaSl7WGAmqQRNUAACAAQAAgAAAAIABAAAAAAAAACICA7cr8fTHOPtE+t0zM3iWJvpfPvsNaVyQ0Sar6nIe9tQXGNm763pUAACAAQAAgAAAAIABAAAAAAAAAAAA".to_string()) .unwrap() From 15503feb6003880d2dc9e7eac147f2e1ce3ec2e5 Mon Sep 17 00:00:00 2001 From: thunderbiscuit Date: Mon, 16 Nov 2026 14:41:39 -0500 Subject: [PATCH 2/2] refactor: sign psbt in a single pass and split sign errors --- .../kotlin/org/bitcoindevkit/PsbtTest.kt | 2 +- bdk-ffi/src/bitcoin.rs | 66 ++++++++++--------- bdk-ffi/src/error.rs | 13 +++- 3 files changed, 45 insertions(+), 36 deletions(-) diff --git a/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt b/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt index ab0bb90d..f0865413 100644 --- a/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt +++ b/bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/PsbtTest.kt @@ -60,7 +60,7 @@ class PsbtTest { .feeRate(FeeRate.fromSatPerVb(22uL)) .finish(wallet) - val psbtSignedResult = psbt.sign(listOf(BIP86_DESCRIPTOR)) + val psbtSignedResult = psbt.sign(listOf(BIP86_DESCRIPTOR, BIP86_CHANGE_DESCRIPTOR)) assertTrue( psbtSignedResult.errors.isEmpty(), diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs index bd7a4755..a8ad27dc 100644 --- a/bdk-ffi/src/bitcoin.rs +++ b/bdk-ffi/src/bitcoin.rs @@ -1,6 +1,6 @@ use crate::error::{ AddressParseError, Bip32Error, ExtractTxError, FeeRateError, FromScriptError, HashParseError, - PsbtError, PsbtParseError, PsbtSignError, TransactionError, + InputSignError, PsbtError, PsbtParseError, PsbtSignError, TransactionError, }; use crate::error::{ParseAmountError, PsbtFinalizeError}; use crate::keys::DerivationPath; @@ -35,11 +35,13 @@ use bdk_wallet::bitcoin::TxOut as BdkTxOut; use bdk_wallet::bitcoin::Txid as BitcoinTxid; use bdk_wallet::bitcoin::Weight; use bdk_wallet::bitcoin::Wtxid as BitcoinWtxid; +use bdk_wallet::keys::KeyMap; +use bdk_wallet::miniscript::descriptor::KeyMapWrapper; use bdk_wallet::miniscript::psbt::PsbtExt; use bdk_wallet::serde_json; use crate::descriptor::Descriptor; -use std::collections::{BTreeSet, HashMap}; +use std::collections::HashMap; use std::convert::TryFrom; use std::fmt::Display; use std::fs::File; @@ -1585,9 +1587,9 @@ impl Psbt { /// Signs the inputs of this PSBT using the secret keys held by the given descriptors. /// /// Pass every descriptor that may own inputs of this transaction (for example a wallet's - /// external and internal descriptors). Each descriptor is tried against every input, and keys - /// that do not match an input are ignored. This function does not support scripts that contain - /// `OP_CODESEPARATOR`. + /// external and internal descriptors). The secret keys of all descriptors are combined and + /// tried against every input in a single pass; keys that do not match an input are ignored. + /// This function does not support scripts that contain `OP_CODESEPARATOR`. /// /// # Returns /// @@ -1598,40 +1600,40 @@ impl Psbt { /// /// # Errors /// - /// Returns `SignError::NoSecretKeys` if none of the descriptors contain secret keys. + /// Returns `PsbtSignError::NoSecretKeys` if none of the descriptors contain secret keys. + /// Problems with individual inputs are not returned as an error; they are reported in + /// `PsbtSignResult::errors`. pub fn sign(&self, descriptors: Vec>) -> Result { - if descriptors.iter().all(|d| d.key_map.is_empty()) { + let key_map: KeyMap = descriptors.iter().flat_map(|d| d.key_map.clone()).collect(); + if key_map.is_empty() { return Err(PsbtSignError::NoSecretKeys); } + let keys = KeyMapWrapper::from(key_map); let mut psbt = self.0.lock().unwrap(); let secp = Secp256k1::new(); - let mut signed_inputs = BTreeSet::new(); - let mut errors = HashMap::new(); - - for descriptor in descriptors.iter().filter(|d| !d.key_map.is_empty()) { - let keys = - bdk_wallet::miniscript::descriptor::KeyMapWrapper::from(descriptor.key_map.clone()); - let (used, errs) = match psbt.sign(&keys, &secp) { - Ok(used) => (used, Default::default()), - Err((used, errs)) => (used, errs), - }; - signed_inputs.extend( - used.into_iter() - .filter(|(_, keys)| match keys { - BdkSigningKeys::Ecdsa(k) => !k.is_empty(), - BdkSigningKeys::Schnorr(k) => !k.is_empty(), - }) - .map(|(index, _)| index as u64), - ); - errors.extend( - errs.into_iter() - .map(|(index, error)| (index as u64, PsbtSignError::from(error))), - ); - } + let (used, errors) = match psbt.sign(&keys, &secp) { + Ok(used) => (used, Default::default()), + Err((used, errors)) => (used, errors), + }; + + // `used` has an entry for every input that was attempted, including inputs where no key + // matched (with an empty key list). Only report inputs that actually received a signature. + let signed_inputs = used + .into_iter() + .filter(|(_, keys)| match keys { + BdkSigningKeys::Ecdsa(k) => !k.is_empty(), + BdkSigningKeys::Schnorr(k) => !k.is_empty(), + }) + .map(|(index, _)| index as u64) + .collect(); + let errors = errors + .into_iter() + .map(|(index, error)| (index as u64, InputSignError::from(error))) + .collect(); Ok(PsbtSignResult { - signed_inputs: signed_inputs.into_iter().collect(), + signed_inputs, errors, }) } @@ -1731,7 +1733,7 @@ pub struct PsbtSignResult { /// Inputs that received at least one signature in this call. pub signed_inputs: Vec, /// Errors encountered while attempting to sign, keyed by input index. - pub errors: HashMap, + pub errors: HashMap, } impl Display for PsbtSignResult { diff --git a/bdk-ffi/src/error.rs b/bdk-ffi/src/error.rs index a6eeac6d..2209a3f0 100644 --- a/bdk-ffi/src/error.rs +++ b/bdk-ffi/src/error.rs @@ -869,9 +869,18 @@ pub enum SignerError { Psbt { error_message: String }, } +/// An error that prevents `Psbt::sign` from attempting to sign at all. #[derive(Debug, thiserror::Error, uniffi::Error)] #[uniffi::export(Debug, Display)] pub enum PsbtSignError { + #[error("none of the provided descriptors contain secret keys")] + NoSecretKeys, +} + +/// An error encountered while signing a single PSBT input, reported in `PsbtSignResult::errors`. +#[derive(Debug, thiserror::Error, uniffi::Error)] +#[uniffi::export(Debug, Display)] +pub enum InputSignError { #[error("index out of bounds {error_message}")] IndexOutOfBounds { error_message: String }, #[error("invalid sighash type")] @@ -904,13 +913,11 @@ pub enum PsbtSignError { WrongSigningAlgorithm, #[error("signing request currently unsupported")] Unsupported, - #[error("none of the provided descriptors contain secret keys")] - NoSecretKeys, #[error("unknown signing error")] Unknown, } -impl From for PsbtSignError { +impl From for InputSignError { fn from(error: BdkSignError) -> Self { match error { BdkSignError::IndexOutOfBounds(e) => Self::IndexOutOfBounds {