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..f0865413 --- /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, BIP86_CHANGE_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..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, TransactionError, + InputSignError, 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; @@ -34,9 +35,12 @@ 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::HashMap; use std::convert::TryFrom; use std::fmt::Display; @@ -1579,6 +1583,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). 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 + /// + /// 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 `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 { + 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 (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, + errors, + }) + } } impl From for Psbt { @@ -1669,6 +1727,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..2209a3f0 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,86 @@ 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")] + 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("unknown signing error")] + Unknown, +} + +impl From for InputSignError { + 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()