diff --git a/bdk-ffi/src/bitcoin.rs b/bdk-ffi/src/bitcoin.rs
index f17a8383..dd977742 100644
--- a/bdk-ffi/src/bitcoin.rs
+++ b/bdk-ffi/src/bitcoin.rs
@@ -4,6 +4,7 @@ use crate::error::{
 };
 use crate::error::{ParseAmountError, PsbtFinalizeError};
 use crate::{impl_from_core_type, impl_hash_like, impl_into_core_type};
+use std::collections::HashMap;
 
 use bdk_wallet::bitcoin::address::NetworkChecked;
 use bdk_wallet::bitcoin::address::NetworkUnchecked;
@@ -14,7 +15,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 +503,238 @@ impl Display for Transaction {
     }
 }
 
+#[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>,
+}
+
+#[derive(Clone, Debug, uniffi::Record)]
+pub struct KeySource {
+    pub fingerprint: String,
+    pub path: String,
+}
+
+/// 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: HashMap<String, Vec<u8>>,
+    /// 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: HashMap<String, KeySource>,
+
+    /// 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: HashMap<String, Vec<u8>>,
+    /// SHA256 hash to preimage map.
+    pub sha256_preimages: HashMap<String, Vec<u8>>,
+    /// HASH160 hash to preimage map.
+    pub hash160_preimages: HashMap<String, Vec<u8>>,
+    /// HASH256 hash to preimage map.
+    pub hash256_preimages: HashMap<String, Vec<u8>>,
+    /// 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)| (k.to_string(), v.to_vec()))
+                .collect(),
+            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(|(pk, (fingerprint, deriv_path))| {
+                    (
+                        pk.to_string(),
+                        KeySource {
+                            fingerprint: fingerprint.to_string(),
+                            path: deriv_path.to_string(),
+                        },
+                    )
+                })
+                .collect(),
+            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)| (k.to_string(), v.clone()))
+                .collect(),
+            sha256_preimages: input
+                .sha256_preimages
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.clone()))
+                .collect(),
+            hash160_preimages: input
+                .hash160_preimages
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.clone()))
+                .collect(),
+            hash256_preimages: input
+                .hash256_preimages
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.clone()))
+                .collect(),
+            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 +860,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 {
diff --git a/bdk-ffi/src/tests/bitcoin.rs b/bdk-ffi/src/tests/bitcoin.rs
index 86c11b7a..a5fd62ff 100644
--- a/bdk-ffi/src/tests/bitcoin.rs
+++ b/bdk-ffi/src/tests/bitcoin.rs
@@ -1,4 +1,5 @@
 use crate::bitcoin::{Address, Network, Psbt};
+use bdk_electrum::bdk_core::bitcoin::hex::DisplayHex;
 
 #[test]
 fn test_is_valid_for_network() {
@@ -357,8 +358,7 @@ fn test_to_address_data() {
 
 #[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);
@@ -369,3 +369,113 @@ fn test_psbt_spend_utxo() {
         "Psbt utxo does not match the expected value"
     );
 }
+
+#[test]
+fn test_psbt_input_length() {
+    let psbt = sample_psbt2();
+    let psbt_inputs = psbt.input();
+    println!("Psbt Input: {:?}", psbt_inputs);
+
+    let unknown = &psbt_inputs[0].unknown;
+    println!("Unknown field in Psbt Input: {:?}", unknown);
+    assert_eq!(psbt_inputs.len(), 1);
+}
+
+#[test]
+fn test_psbt_input_partial_sigs() {
+    let psbt = sample_psbt();
+    let psbt_inputs = psbt.input();
+    println!("Psbt Input: {:?}", psbt_inputs);
+    assert_eq!(psbt_inputs.len(), 1);
+
+    let psbt_input = &psbt_inputs[0];
+
+    let partial_sigs = &psbt_input.partial_sigs;
+    let signatures_count = partial_sigs.len();
+    assert_eq!(signatures_count, 3, "There should be 3 partial signatures");
+
+    let public_key = "032e15f9dfd07dfef5cf33d7c4ae05586e71fb02ff2aef77cbf2c6e69fb4ac8db1";
+    let signature: Option<Vec<u8>> = partial_sigs.get(public_key).cloned();
+    println!("Signature for pubkey {}: {:?}", public_key, signature);
+    assert!(
+        signature.is_some(),
+        "Signature for the given pubkey should be present"
+    );
+
+    // Convert signature from bytes to hex string (Including last byte 0x01 for sighash type)
+    let signature_hex = DisplayHex::to_lower_hex_string(&signature.unwrap());
+    println!("Signature in hex: {}", signature_hex);
+
+    let expected_signature_hex = "3045022100f5bd0e740480b343f6ba14229e337b4063f98d7fdbdf62dc4a10669f2f14d1150220179bc6f0836e97210a3a8b02138c8f2753f340c0ce891a6a51b357b5d54ec6e201";
+    assert_eq!(
+        signature_hex, expected_signature_hex,
+        "Signature hex does not match the expected value"
+    );
+}
+
+#[test]
+fn test_psbt_input_bip32_derivation() {
+    let psbt = sample_psbt();
+    let psbt_inputs = psbt.input();
+    assert_eq!(psbt_inputs.len(), 1);
+
+    let psbt_input = &psbt_inputs[0];
+    let bip32_derivations = &psbt_input.bip32_derivation;
+    let derivations_count = bip32_derivations.len();
+    assert_eq!(derivations_count, 3, "There should be 3 BIP32 derivations");
+
+    let public_key = "032e15f9dfd07dfef5cf33d7c4ae05586e71fb02ff2aef77cbf2c6e69fb4ac8db1";
+    let derivation = bip32_derivations.get(public_key);
+    println!(
+        "BIP32 Derivation for pubkey {}: {:?}",
+        public_key, derivation
+    );
+    assert!(
+        derivation.is_some(),
+        "BIP32 derivation for the given pubkey should be present"
+    );
+
+    let fingerprint = &derivation.unwrap().fingerprint;
+    let expected_fingerprint = "09aa4113";
+    assert_eq!(
+        fingerprint, &expected_fingerprint,
+        "Fingerprint does not match the expected value"
+    );
+
+    let derivation_path = &derivation.unwrap().path;
+    let expected_derivation_path = "84'/1'/0'/0/0";
+    assert_eq!(
+        derivation_path, &expected_derivation_path,
+        "Derivation path does not match the expected value"
+    );
+}
+
+#[test]
+fn test_psbt_input_witness_script() {
+    let psbt = sample_psbt();
+    let psbt_inputs = psbt.input();
+    assert_eq!(psbt_inputs.len(), 1);
+
+    let psbt_input = &psbt_inputs[0];
+    let witness_script = psbt_input
+        .witness_script
+        .as_ref()
+        .expect("Witness script should be present");
+    let byte_witness = witness_script.to_bytes();
+    let witness_hex = DisplayHex::to_lower_hex_string(&byte_witness);
+    let expected_witness_hex = "5221035b4c63ee3a120c481d4d7c6e01e752f00094090cab92dfc24a4e199f7bb0329121032e15f9dfd07dfef5cf33d7c4ae05586e71fb02ff2aef77cbf2c6e69fb4ac8db12103f9a0b32bd9dc97085b6cdeca6c854651018b599b2371aa963f193d805786f85c53ae";
+    assert_eq!(
+        witness_hex, expected_witness_hex,
+        "Witness script hex does not match the expected value"
+    );
+}
+
+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()
+}
+
+fn sample_psbt2() -> Psbt {
+    Psbt::new("cHNidP8BAFMBAAAAATkUkZZWjQ4TAMqaOkez2dl2+5yBsfd38qS6x8fkjesmAQAAAAD/////AXL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAAAAAE8BBIiyHgAAAAAAAAAAAIc9/4HAL1JWI/0f5RZ+rDpVoEnePTFLtC7iJ//tN9UIAzmjYBMwFZfa70H75ZOgLMUT0LVVJ+wt8QUOLo/0nIXCDN6tvu8AAACAAQAAABD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFAAEAjwEAAAAAAQGJo8ceq00g4Dcbu6TMaY+ilclGOvouOX+FM8y2L5Vn5QEAAAAXFgAUvhjRUqmwEgOdrz2n3k9TNJ7suYX/////AXL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUAAAAAAQEgcv74TiwAAAAXqRQzlyW6Ie/WKsdTqbzQZ9bHpqOdBYciAgM5iA3JI5S3NV49BDn6KDwx3nWQgS6gEcQkXAZ0poXog0cwRAIgT2fir7dhQtRPrliiSV0zo0GdqibNDbjQTzRStjKJrA8CIBB2Kp+2fpTMXK2QJvbcmf9/Bw9CeNMPvH0Mhp3TjH/nAQEDBIMAAAABBAFRIgYDOYgNySOUtzVePQQ5+ig8Md51kIEuoBHEJFwGdKaF6IMM3q2+7wAAAIABAAAAAQgGAgIBAwEFFQoYn3yLGjhv/o7tkbODDHp7zR53jAIBAiELoShx/uIQ+4YZKR6uoZRYHL0lMeSyN1nSJfaAaSP2MiICAQIVDBXMSeGRy8Ug2RlEYApct3r2qjKRAgECIQ12pWrO2RXSUT3NhMLDeLLoqlzWMrW3HKLyrFsOOmSb2wIBAhD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFACICAzmIDckjlLc1Xj0EOfooPDHedZCBLqARxCRcBnSmheiDDN6tvu8AAACAAQAAABD8BXByZWZ4KnRlc3Rfa2V5AwUGBwMJAAEDAwQFAA==".to_string())
+        .unwrap()
+}