feat: Expose psbt output

Author: ItoroD

bdk-ffi/src/bitcoin.rs

@@ -19,6 +19,7 @@ use bdk_wallet::bitcoin::hashes::sha256::Hash as BitcoinSha256Hash;
 use bdk_wallet::bitcoin::hashes::sha256d::Hash as BitcoinDoubleSha256Hash;
 use bdk_wallet::bitcoin::io::Cursor;
 use bdk_wallet::bitcoin::psbt::Input as BdkInput;
+use bdk_wallet::bitcoin::psbt::Output as BdkOutput;
 use bdk_wallet::bitcoin::secp256k1::Secp256k1;
 use bdk_wallet::bitcoin::Amount as BdkAmount;
 use bdk_wallet::bitcoin::BlockHash as BitcoinBlockHash;
@@ -767,6 +768,183 @@ impl From<&BdkInput> for Input {
     }
 }
 
+#[derive(Clone, Debug, uniffi::Enum)]
+pub enum TapLeaf {
+    /// A known script
+    Script,
+    /// Hidden node
+    Hidden,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct TapLeafInfo {
+    /// Type of leaf
+    pub leaf_type: TapLeaf,
+    /// The script if this is a Script leaf
+    pub script: Option<Arc<Script>>,
+    /// The version if this is a Script leaf
+    pub version: Option<u8>,
+    /// The hash if this is a Hidden leaf
+    pub hash: Option<String>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct LeafNode {
+    /// The tap leaf info (script or hidden)
+    pub leaf: TapLeafInfo,
+    /// The merkle proof (hashing partners) to get this node as hex strings
+    pub merkle_branch: Vec<String>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct TapTree {
+    /// TapTree merkle root (TapNodeHash) as hex string
+    pub hash: String,
+    /// Whether the tree contains hidden nodes
+    pub has_hidden_nodes: bool,
+    /// Leaf nodes in this tree
+    pub leaves: Vec<LeafNode>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct Output {
+    /// The redeem script for this output.
+    pub redeem_script: Option<Arc<Script>>,
+    /// The witness script for this output.
+    pub witness_script: Option<Arc<Script>>,
+    /// Map of public keys needed to spend this output to their corresponding
+    /// master key fingerprints and derivation paths.
+    pub bip32_derivation: HashMap<String, KeySource>,
+    /// Taproot Internal key.
+    pub tap_internal_key: Option<String>,
+    /// Taproot Output tree (structured record).
+    pub tap_tree: Option<TapTree>,
+    /// Map of tap root x only keys to origin info and leaf hashes contained in it.
+    pub tap_key_origins: HashMap<String, TapKeyOrigin>,
+    /// Proprietary key-value pairs for this output.
+    pub proprietary: HashMap<ProprietaryKey, Vec<u8>>,
+    /// Unknown key-value pairs for this output.
+    pub unknown: HashMap<Key, Vec<u8>>,
+}
+
+impl From<&BdkOutput> for Output {
+    fn from(output: &BdkOutput) -> Self {
+        Output {
+            redeem_script: output
+                .redeem_script
+                .as_ref()
+                .map(|s| Arc::new(Script(s.clone()))),
+            witness_script: output
+                .witness_script
+                .as_ref()
+                .map(|s| Arc::new(Script(s.clone()))),
+            bip32_derivation: output
+                .bip32_derivation
+                .iter()
+                .map(|(pk, (fingerprint, deriv_path))| {
+                    (
+                        pk.to_string(),
+                        KeySource {
+                            fingerprint: fingerprint.to_string(),
+                            path: Arc::new(deriv_path.clone().into()),
+                        },
+                    )
+                })
+                .collect(),
+            tap_internal_key: output.tap_internal_key.as_ref().map(|k| k.to_string()),
+            tap_tree: output.tap_tree.as_ref().map(|t| {
+                let node_info = t.node_info();
+                let leaves = node_info
+                    .leaf_nodes()
+                    .map(|leaf_node| {
+                        let (leaf_type, script, version, hash) = match leaf_node.leaf() {
+                            bdk_wallet::bitcoin::taproot::TapLeaf::Script(script, ver) => {
+                                (TapLeaf::Script,
+                                 Some(Arc::new(Script(script.clone()))),
+                                 Some(ver.to_consensus()),
+                                 None)
+                            }
+                            bdk_wallet::bitcoin::taproot::TapLeaf::Hidden(hash) => {
+                                (TapLeaf::Hidden,
+                                 None,
+                                 None,
+                                 Some(hash.to_string()))
+                            }
+                        };
+
+                        let leaf = TapLeafInfo {
+                            leaf_type,
+                            script,
+                            version,
+                            hash,
+                        };
+
+                        LeafNode {
+                            leaf,
+                            merkle_branch: leaf_node
+                                .merkle_branch()
+                                .iter()
+                                .map(|h| h.to_string())
+                                .collect(),
+                        }
+                    })
+                    .collect();
+
+                TapTree {
+                    hash: node_info.node_hash().to_string(),
+                    has_hidden_nodes: false,
+                    leaves,
+                }
+            }),
+            tap_key_origins: output
+                .tap_key_origins
+                .iter()
+                .map(|(k, v)| {
+                    let key = k.to_string();
+                    let value = TapKeyOrigin {
+                        tap_leaf_hashes: v.0.iter().map(|h| h.to_string()).collect(),
+                        key_source: KeySource {
+                            // Unnecessary spaces being added by fmt. We use #[rustfmt::skip] to avoid them for now.
+                            #[rustfmt::skip]
+                            fingerprint: v.1.0.to_string(),
+                            #[rustfmt::skip]
+                            path: Arc::new(v.1.1.clone().into()),
+                        },
+                    };
+                    (key, value)
+                })
+                .collect(),
+            proprietary: output
+                .proprietary
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        ProprietaryKey {
+                            prefix: k.prefix.clone(),
+                            subtype: k.subtype,
+                            key: k.key.clone(),
+                        },
+                        v.to_vec(),
+                    )
+                })
+                .collect(),
+            unknown: output
+                .unknown
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        Key {
+                            key: k.key.clone(),
+                            type_value: k.type_value,
+                        },
+                        v.to_vec(),
+                    )
+                })
+                .collect(),
+        }
+    }
+}
+
 /// A Partially Signed Transaction.
 #[derive(uniffi::Object)]
 pub struct Psbt(pub(crate) Mutex<BdkPsbt>);
@@ -898,6 +1076,12 @@ impl Psbt {
         let psbt = self.0.lock().unwrap();
         psbt.inputs.iter().map(|input| input.into()).collect()
     }
+
+    /// The corresponding key-value map for each output in the unsigned transaction.
+    pub fn output(&self) -> Vec<Output> {
+        let psbt = self.0.lock().unwrap();
+        psbt.outputs.iter().map(|o| o.into()).collect()
+    }
 }
 
 impl From<BdkPsbt> for Psbt {

bdk-ffi/src/tests/bitcoin.rs

@@ -524,6 +524,15 @@ fn test_psbt_input_proprietary() {
     );
 }
 
+#[test]
+fn test_psbt_output_length() {
+    let psbt = sample_psbt();
+    let psbt_outputs = psbt.output();
+    println!("Psbt Output: {:?}", psbt_outputs);
+
+    assert_eq!(psbt_outputs.len(), 2);
+}
+
 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()