Add code example for every supported backend

Author: w0xlt

Cargo.toml

@@ -108,7 +108,7 @@ path = "examples/compiler.rs"
 required-features = ["compiler"]
 
 [workspace]
-members = ["macros"]
+members = ["macros", "examples/backend"]
 [package.metadata.docs.rs]
 features = ["compiler", "electrum", "esplora", "ureq", "compact_filters", "rpc", "key-value-db", "sqlite", "all-keys", "verify"]
 # defines the configuration attribute `docsrs`

examples/backend/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "backend_test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bdk = { path = "../..", default-feature = false, features = ["all-keys", "compact_filters", "compiler", "key-value-db", "rpc", "use-esplora-ureq"] }
+dirs-next = "2.0"

examples/backend/src/main.rs

@@ -0,0 +1,96 @@
+use std::env;
+
+use bdk::bitcoin::Network;
+
+mod wallet_common;
+mod wallet_core;
+mod wallet_electrum;
+mod wallet_esplora;
+mod wallet_neutrino;
+
+fn run_electrum() {
+    let network = Network::Testnet;
+
+    let mnemonic_words =
+        "health lyrics appear aunt either wrist maple hover family episode seven maze";
+
+    let electrum_url = "ssl://electrum.blockstream.info:60002";
+
+    wallet_electrum::run(network, electrum_url, mnemonic_words);
+}
+
+fn run_esplora() {
+    let network = Network::Testnet;
+
+    let mnemonic_words =
+        "health lyrics appear aunt either wrist maple hover family episode seven maze";
+
+    let esplora_url = "https://blockstream.info/testnet/api";
+
+    wallet_esplora::run(network, esplora_url, mnemonic_words);
+}
+
+fn run_neutrino() {
+    // let network = Network::Bitcoin;
+    let network = Network::Testnet;
+
+    // let neutrino_url = "btcd-mainnet.lightning.computer:8333";
+    // let neutrino_url = "bb1.breez.technology:8333";
+    let neutrino_url = "faucet.lightning.community:18333";
+
+    let mnemonic_words =
+        "health lyrics appear aunt either wrist maple hover family episode seven maze";
+
+    wallet_neutrino::run(network, neutrino_url, mnemonic_words)
+}
+
+fn run_rpc_core() {
+    let network = Network::Signet;
+
+    let mnemonic_words =
+        "health lyrics appear aunt either wrist maple hover family episode seven maze";
+
+    let rpc_url = "127.0.0.1:38332";
+
+    let username = "admin";
+    let password = "password";
+
+    wallet_core::run(network, rpc_url, username, password, mnemonic_words);
+}
+
+fn main() {
+    // This program can be started with the following command:
+    // cargo run esplora
+    // The argument represents the backend.
+    // The options are electrum, esplora, rpc_core or neutrino
+
+    /*
+    // Generate a new mnemonic
+    let mnemonic: GeneratedKey<_, miniscript::Segwitv0> = Mnemonic::generate((WordCount::Words12, Language::English)).unwrap();
+
+    // Convert mnemonic to string
+    let mnemonic_words = mnemonic.to_string();
+
+    println!("mnemonic {:?}", mnemonic_words);
+    */
+
+    let backend_options = vec!["electrum", "esplora", "rpc_core", "neutrino"];
+
+    let args: Vec<String> = env::args().collect();
+
+    let mut selected_option = if args.len() < 2 { "electrum" } else { &args[1] };
+
+    if !backend_options.contains(&selected_option) {
+        selected_option = "electrum";
+    }
+
+    println!("Running {:?} example", selected_option);
+
+    match selected_option {
+        "electrum" => run_electrum(),
+        "esplora" => run_esplora(),
+        "neutrino" => run_neutrino(),
+        "rpc_core" => run_rpc_core(),
+        _ => println!("Error !"),
+    }
+}

examples/backend/src/wallet_common.rs

@@ -0,0 +1,46 @@
+use bdk::bitcoin::util::bip32::ExtendedPrivKey;
+use bdk::bitcoin::{Address, Network, Transaction};
+use bdk::database::BatchDatabase;
+use bdk::keys::{DerivableKey, ExtendedKey};
+
+use bdk::keys::bip39::Mnemonic;
+
+use bdk::wallet::signer::SignOptions;
+use bdk::Wallet;
+
+use std::str::FromStr;
+
+pub fn mnemonic_to_xprv(network: &Network, mnemonic_words: &str) -> ExtendedPrivKey {
+    // Parse a mnemonic
+    let mnemonic = Mnemonic::parse(mnemonic_words).unwrap();
+
+    // Generate the extended key
+    let xkey: ExtendedKey = mnemonic.into_extended_key().unwrap();
+
+    // Get xprv from the extended key
+    xkey.into_xprv(*network).unwrap()
+}
+
+pub fn build_signed_tx<B, D: BatchDatabase>(
+    wallet: &Wallet<B, D>,
+    recipient_address: &str,
+    amount: u64,
+) -> Transaction {
+    // Create a transaction builder
+    let mut tx_builder = wallet.build_tx();
+
+    let to_address = Address::from_str(recipient_address).unwrap();
+
+    // Set recipient of the transaction
+    tx_builder.set_recipients(vec![(to_address.script_pubkey(), amount)]);
+
+    // Finalise the transaction and extract PSBT
+    let (mut psbt, _) = tx_builder.finish().unwrap();
+
+    // Sign the above psbt with signing option
+    wallet.sign(&mut psbt, SignOptions::default()).unwrap();
+
+    // Extract the final transaction
+    psbt.extract_tx()
+
+}

examples/backend/src/wallet_core.rs

@@ -0,0 +1,122 @@
+use bdk::bitcoin::secp256k1::Secp256k1;
+use bdk::bitcoin::util::bip32::ExtendedPrivKey;
+use bdk::bitcoin::Network;
+use bdk::blockchain::{ConfigurableBlockchain, LogProgress};
+
+use bdk::template::Bip84;
+use bdk::wallet::export::WalletExport;
+use bdk::KeychainKind;
+
+use bdk::blockchain::rpc::{Auth, RpcBlockchain, RpcConfig};
+
+use bdk::wallet::{wallet_name_from_descriptor, AddressIndex};
+use bdk::Wallet;
+
+use bdk::sled::{self, Tree};
+
+use crate::wallet_common::{build_signed_tx, mnemonic_to_xprv};
+
+fn load_or_create_wallet(
+    network: &Network,
+    rpc_url: &str,
+    username: &str,
+    password: &str,
+    xpriv: &ExtendedPrivKey,
+) -> Wallet<RpcBlockchain, Tree> {
+    let auth = Auth::UserPass {
+        username: username.to_string(),
+        password: password.to_string(),
+    };
+
+    // Use deterministic wallet name derived from descriptor
+    let wallet_name = wallet_name_from_descriptor(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        &Secp256k1::new(),
+    )
+    .unwrap();
+
+    println!("wallet name: {:?}", wallet_name);
+
+    // Setup the RPC configuration
+    let rpc_config = RpcConfig {
+        url: rpc_url.to_string(),
+        auth,
+        network: *network,
+        wallet_name: wallet_name.clone(),
+        skip_blocks: Some(70_000), // Some(block_count)
+    };
+
+    // Use the above configuration to create a RPC blockchain backend
+    let blockchain = RpcBlockchain::from_config(&rpc_config).unwrap();
+
+    // Create the datadir to store wallet data
+    let mut datadir = dirs_next::home_dir().unwrap();
+    datadir.push(".bdk-wallets");
+    datadir.push(wallet_name.clone());
+    let database = sled::open(datadir).unwrap();
+    let db_tree = database.open_tree(wallet_name).unwrap();
+
+    // Combine everything and finally create the BDK wallet structure
+    let wallet = Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        db_tree,
+        blockchain,
+    )
+    .unwrap();
+
+    // Sync the wallet
+    //let sync_result = wallet.sync(LogProgress, None);
+    wallet.sync(LogProgress, None).unwrap();
+
+    wallet
+}
+
+pub fn run(network: Network, rpc_url: &str, username: &str, password: &str, mnemonic_words: &str) {
+    let xpriv = mnemonic_to_xprv(&network, mnemonic_words);
+
+    let wallet = load_or_create_wallet(&network, rpc_url, username, password, &xpriv);
+
+    println!(
+        "mnemonic: {}\n\nrecv desc (pub key): {:#?}\n\nchng desc (pub key): {:#?}",
+        mnemonic_words,
+        wallet
+            .get_descriptor_for_keychain(KeychainKind::External)
+            .to_string(),
+        wallet
+            .get_descriptor_for_keychain(KeychainKind::Internal)
+            .to_string()
+    );
+
+    // Fetch a fresh address to receive coins
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("new address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("balance: {}", balance);
+
+    if balance > 5500 {
+        let recipient_address = "tb1q766f5v4h9ml8dh99ev5ertg2ysrjz2kkuzq8up";
+
+        let tx = build_signed_tx(&wallet, recipient_address, 5000);
+
+        // Broadcast the transaction
+        let tx_id = wallet.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx_id.to_string());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = WalletExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}

examples/backend/src/wallet_electrum.rs

@@ -0,0 +1,70 @@
+use bdk::bitcoin::util::bip32::ExtendedPrivKey;
+use bdk::bitcoin::Network;
+use bdk::blockchain::{noop_progress, ElectrumBlockchain};
+use bdk::database::MemoryDatabase;
+use bdk::template::Bip84;
+use bdk::wallet::export::WalletExport;
+use bdk::{KeychainKind, Wallet};
+
+use bdk::electrum_client::Client;
+use bdk::wallet::AddressIndex;
+
+use crate::wallet_common::{build_signed_tx, mnemonic_to_xprv};
+
+pub fn load_or_create_wallet(
+    electrum_url: &str,
+    network: &Network,
+    xpriv: &ExtendedPrivKey,
+) -> Wallet<ElectrumBlockchain, MemoryDatabase> {
+    // Apparently it works only with Electrs (not EletrumX)
+    let client = Client::new(electrum_url).unwrap();
+
+    let wallet = Wallet::new(
+        Bip84(*xpriv, KeychainKind::External),
+        Some(Bip84(*xpriv, KeychainKind::Internal)),
+        *network,
+        MemoryDatabase::default(),
+        ElectrumBlockchain::from(client),
+    )
+    .unwrap();
+
+    wallet.sync(noop_progress(), None).unwrap();
+
+    wallet
+}
+
+pub fn run(network: Network, electrum_url: &str, mnemonic_words: &str) {
+    let xpriv = mnemonic_to_xprv(&network, mnemonic_words);
+
+    let wallet = load_or_create_wallet(electrum_url, &network, &xpriv);
+
+    let address = wallet.get_address(AddressIndex::New).unwrap().address;
+
+    println!("address: {}", address);
+
+    let balance = wallet.get_balance().unwrap();
+
+    println!("balance: {}", balance);
+
+    if balance > 10500 {
+        // tBTC address of https://testnet-faucet.mempool.co/
+        let recipient_address = "mkHS9ne12qx9pS9VojpwU5xtRd4T7X7ZUt";
+
+        let amount = 9359;
+
+        let tx = build_signed_tx(&wallet, recipient_address, amount);
+
+        let tx_id = wallet.broadcast(&tx).unwrap();
+
+        println!("tx id: {}", tx_id.to_string());
+    } else {
+        println!("Insufficient Funds. Fund the wallet with the address above");
+    }
+
+    let export = WalletExport::export_wallet(&wallet, "exported wallet", true)
+        .map_err(ToString::to_string)
+        .map_err(bdk::Error::Generic)
+        .unwrap();
+
+    println!("------\nWallet Backup: {}", export.to_string());
+}