feat: Add Input for PSBT

ItoroD · ItoroD · commit f1fa7bec4e52 · 2025-09-24T21:58:19.000+01:00
This allows easier access to the inputs of our PSBT type
diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs
@@ -14,7 +14,9 @@ use bdk_wallet::bitcoin::consensus::encode::serialize;
 use bdk_wallet::bitcoin::consensus::Decodable;
 use bdk_wallet::bitcoin::hashes::sha256::Hash as BitcoinSha256Hash;
 use bdk_wallet::bitcoin::hashes::sha256d::Hash as BitcoinDoubleSha256Hash;
+use bdk_wallet::bitcoin::hex::DisplayHex;
 use bdk_wallet::bitcoin::io::Cursor;
+use bdk_wallet::bitcoin::psbt::Input as BdkInput;
 use bdk_wallet::bitcoin::secp256k1::Secp256k1;
 use bdk_wallet::bitcoin::Amount as BdkAmount;
 use bdk_wallet::bitcoin::BlockHash as BitcoinBlockHash;
@@ -500,6 +502,267 @@ impl Display for Transaction {
     }
 }
 
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct PartialSig {
+    pub pubkey: String,
+    pub signature: Vec<u8>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct Bip32Derivation {
+    /// hex-encoded public key (serialized)
+    pub pubkey: String,
+    /// master key fingerprint
+    pub fingerprint: String,
+    /// derivation path segments
+    pub path: String,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct PreimagePair {
+    /// hex-encoded hash (RIPEMD160 / SHA256 / HASH160 / HASH256 as applicable)
+    pub hash: String,
+    /// preimage bytes
+    pub preimage: Vec<u8>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct TapScriptSig {
+    /// x-only pubkey as hex
+    pub xonly_pubkey: String,
+    /// tap leaf hash as hex
+    pub leaf_hash: String,
+    /// signature bytes
+    pub signature: Vec<u8>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct TapScriptEntry {
+    /// control block bytes
+    pub control_block: String,
+    /// script (reuse existing `Script` FFI type)
+    pub script: Arc<Script>,
+    /// leaf version
+    pub leaf_version: u8,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct TapKeyOrigin {
+    /// x-only pubkey as hex
+    pub xonly_pubkey: String,
+    /// leaf hashes as hex strings
+    pub leaf_hashes: Vec<String>,
+    /// master key fingerprint
+    pub fingerprint: String,
+    /// derivation path segments
+    pub path: String,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct KeyValuePair {
+    /// raw key bytes (for proprietary / unknown keys)
+    pub key: Vec<u8>,
+    /// raw value bytes
+    pub value: Vec<u8>,
+    /// The type of this PSBT key.
+    pub type_value: u8,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct ProprietaryKeyValuePair {
+    /// Proprietary type prefix used for grouping together keys under some application and avoid namespace collision
+    pub prefix: Vec<u8>,
+    /// Custom proprietary subtype
+    pub subtype: u8,
+    /// Additional key bytes (like serialized public key data etc)
+    pub key: Vec<u8>,
+    /// raw value bytes
+    pub value: Vec<u8>,
+}
+
+/// A key-value map for an input of the corresponding index in the unsigned transaction.
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct Input {
+    /// The non-witness transaction this input spends from. Should only be
+    /// `Option::Some` for inputs which spend non-segwit outputs or
+    /// if it is unknown whether an input spends a segwit output.
+    pub non_witness_utxo: Option<Arc<Transaction>>,
+    /// The transaction output this input spends from. Should only be
+    /// `Option::Some` for inputs which spend segwit outputs,
+    /// including P2SH embedded ones.
+    pub witness_utxo: Option<TxOut>,
+    /// A map from public keys to their corresponding signature as would be
+    // pushed to the stack from a scriptSig or witness for a non-taproot inputs.
+    pub partial_sigs: Vec<PartialSig>,
+    /// The sighash type to be used for this input. Signatures for this input
+    /// must use the sighash type.
+    pub sighash_type: Option<String>,
+    /// The redeem script for this input.
+    pub redeem_script: Option<Arc<Script>>,
+    /// The witness script for this input.
+    pub witness_script: Option<Arc<Script>>,
+    /// A map from public keys needed to sign this input to their corresponding
+    /// master key fingerprints and derivation paths.
+    pub bip32_derivation: Vec<Bip32Derivation>,
+
+    /// The finalized, fully-constructed scriptSig with signatures and any other
+    /// scripts necessary for this input to pass validation.
+    pub final_script_sig: Option<Arc<Script>>,
+
+    /// The finalized, fully-constructed scriptWitness with signatures and any
+    /// other scripts necessary for this input to pass validation.
+    pub final_script_witness: Option<Vec<Vec<u8>>>,
+    /// RIPEMD160 hash to preimage map.
+    pub ripemd160_preimages: Vec<PreimagePair>,
+    /// SHA256 hash to preimage map.
+    pub sha256_preimages: Vec<PreimagePair>,
+    /// HASH160 hash to preimage map.
+    pub hash160_preimages: Vec<PreimagePair>,
+    /// HASH256 hash to preimage map.
+    pub hash256_preimages: Vec<PreimagePair>,
+    /// Serialized taproot signature with sighash type for key spend.
+    pub tap_key_sig: Option<Vec<u8>>,
+    /// Map of `<xonlypubkey>|<leafhash>` with signature.
+    pub tap_script_sigs: Vec<TapScriptSig>,
+    /// Map of Control blocks to Script version pair.
+    pub tap_scripts: Vec<TapScriptEntry>,
+    /// Map of tap root x only keys to origin info and leaf hashes contained in it.
+    pub tap_key_origins: Vec<TapKeyOrigin>,
+    /// Taproot Internal key.
+    pub tap_internal_key: Option<String>,
+    /// Taproot Merkle root.
+    pub tap_merkle_root: Option<String>,
+    /// Proprietary key-value pairs for this input.
+    pub proprietary: Vec<ProprietaryKeyValuePair>,
+    /// Unknown key-value pairs for this input.
+    pub unknown: Vec<KeyValuePair>,
+}
+
+impl From<&BdkInput> for Input {
+    fn from(input: &BdkInput) -> Self {
+        Input {
+            non_witness_utxo: input
+                .non_witness_utxo
+                .as_ref()
+                .map(|tx| Arc::new(Transaction(tx.clone()))),
+            witness_utxo: input.witness_utxo.as_ref().map(TxOut::from),
+            partial_sigs: input
+                .partial_sigs
+                .iter()
+                .map(|(k, v)| PartialSig {
+                    pubkey: k.to_string(),
+                    signature: v.to_vec(),
+                })
+                .collect::<Vec<PartialSig>>(),
+            sighash_type: input.sighash_type.as_ref().map(|s| s.to_string()),
+            redeem_script: input
+                .redeem_script
+                .as_ref()
+                .map(|s| Arc::new(Script(s.clone()))),
+            witness_script: input
+                .witness_script
+                .as_ref()
+                .map(|s| Arc::new(Script(s.clone()))),
+            bip32_derivation: input
+                .bip32_derivation
+                .iter()
+                .map(|(k, v)| Bip32Derivation {
+                    pubkey: k.to_string(),
+                    fingerprint: v.0.to_string(),
+                    path: v.1.to_string(),
+                })
+                .collect::<Vec<Bip32Derivation>>(),
+            final_script_sig: input
+                .final_script_sig
+                .as_ref()
+                .map(|s| Arc::new(Script(s.clone()))),
+            final_script_witness: input.final_script_witness.as_ref().map(|w| w.to_vec()),
+            ripemd160_preimages: input
+                .ripemd160_preimages
+                .iter()
+                .map(|(k, v)| PreimagePair {
+                    hash: k.to_string(),
+                    preimage: v.to_vec(),
+                })
+                .collect::<Vec<PreimagePair>>(),
+            sha256_preimages: input
+                .sha256_preimages
+                .iter()
+                .map(|(k, v)| PreimagePair {
+                    hash: k.to_string(),
+                    preimage: v.to_vec(),
+                })
+                .collect::<Vec<PreimagePair>>(),
+            hash160_preimages: input
+                .hash160_preimages
+                .iter()
+                .map(|(k, v)| PreimagePair {
+                    hash: k.to_string(),
+                    preimage: v.to_vec(),
+                })
+                .collect::<Vec<PreimagePair>>(),
+            hash256_preimages: input
+                .hash256_preimages
+                .iter()
+                .map(|(k, v)| PreimagePair {
+                    hash: k.to_string(),
+                    preimage: v.to_vec(),
+                })
+                .collect::<Vec<PreimagePair>>(),
+            tap_key_sig: input.tap_key_sig.as_ref().map(|s| s.serialize().to_vec()),
+            tap_script_sigs: input
+                .tap_script_sigs
+                .iter()
+                .map(|(k, v)| TapScriptSig {
+                    xonly_pubkey: k.0.to_string(),
+                    leaf_hash: k.1.to_string(),
+                    signature: v.to_vec(),
+                })
+                .collect::<Vec<TapScriptSig>>(),
+            tap_scripts: input
+                .tap_scripts
+                .iter()
+                .map(|(k, v)| TapScriptEntry {
+                    control_block: DisplayHex::to_lower_hex_string(&k.serialize()),
+                    script: Arc::new(v.0.clone().into()),
+                    leaf_version: v.1.to_consensus(),
+                })
+                .collect::<Vec<TapScriptEntry>>(),
+            tap_key_origins: input
+                .tap_key_origins
+                .iter()
+                .map(|(k, v)| TapKeyOrigin {
+                    xonly_pubkey: k.to_string(),
+                    leaf_hashes: v.0.iter().map(|h| h.to_string()).collect(),
+                    fingerprint: v.1 .0.to_string(),
+                    path: v.1 .1.to_string(),
+                })
+                .collect::<Vec<TapKeyOrigin>>(),
+            tap_internal_key: input.tap_internal_key.as_ref().map(|k| k.to_string()),
+            tap_merkle_root: input.tap_merkle_root.as_ref().map(|k| k.to_string()),
+            proprietary: input
+                .proprietary
+                .iter()
+                .map(|(k, v)| ProprietaryKeyValuePair {
+                    key: k.to_key().key.clone(),
+                    subtype: k.subtype,
+                    prefix: k.prefix.to_vec(),
+                    value: v.to_vec(),
+                })
+                .collect(),
+            unknown: input
+                .unknown
+                .iter()
+                .map(|(k, v)| KeyValuePair {
+                    key: k.key.clone(),
+                    value: v.to_vec(),
+                    type_value: k.type_value,
+                })
+                .collect(),
+        }
+    }
+}
+
 /// A Partially Signed Transaction.
 #[derive(uniffi::Object)]
 pub struct Psbt(pub(crate) Mutex<BdkPsbt>);
@@ -625,6 +888,12 @@ impl Psbt {
         let utxo = psbt.spend_utxo(input_index as usize).unwrap();
         serde_json::to_string(&utxo).unwrap()
     }
+
+    /// The corresponding key-value map for each input in the unsigned transaction.
+    pub fn input(&self) -> Vec<Input> {
+        let psbt = self.0.lock().unwrap();
+        psbt.inputs.iter().map(|input| input.into()).collect()
+    }
 }
 
 impl From<BdkPsbt> for Psbt {
@@ -1135,10 +1404,8 @@ mod tests {
 
     #[test]
     fn test_psbt_spend_utxo() {
-        let 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();
+        let psbt = sample_psbt();
         let psbt_utxo = psbt.spend_utxo(0);
-
         println!("Psbt utxo: {:?}", psbt_utxo);
 
         assert_eq!(
@@ -1147,4 +1414,18 @@ mod tests {
             "Psbt utxo does not match the expected value"
         );
     }
+
+    #[test]
+    fn test_psbt_input() {
+        let psbt = sample_psbt();
+        let psbt_inputs = psbt.input();
+        println!("Psbt Input: {:?}", psbt_inputs);
+
+        assert_eq!(psbt_inputs.len(), 1);
+    }
+
+    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()
+    }
 }
