feat: add example with rpc and redb

110CodingP · 110CodingP · commit 28375ab111f5 · 2025-06-21T18:55:30.000+05:30
Also added manifest and binary files that had forgotten to add to git.
diff --git a/examples/example_wallet_esplora_blocking_redb/Cargo.toml b/examples/example_wallet_esplora_blocking_redb/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "example_wallet_esplora_blocking_redb"
+version = "0.1.0"
+edition = "2024"
+authors.workspace = true
+
+[dependencies]
+bdk_wallet = { version = "2.0.0" }
+bdk_esplora = { version = "0.22.0", features = ["blocking"] }
+anyhow = "1"
+bdk_redb = { git = "https://github.com/110CodingP/bdk_redb" }
diff --git a/examples/example_wallet_esplora_blocking_redb/src/main.rs b/examples/example_wallet_esplora_blocking_redb/src/main.rs
@@ -0,0 +1,90 @@
+use std::{collections::BTreeSet, io::Write};
+
+use bdk_esplora::{esplora_client, EsploraExt};
+use bdk_wallet::{
+    bitcoin::{Amount, Network},
+    KeychainKind, SignOptions, Wallet,
+};
+
+use bdk_redb::Store;
+const DB_PATH: &str = "bdk-example-esplora-blocking.db";
+const SEND_AMOUNT: Amount = Amount::from_sat(5000);
+const STOP_GAP: usize = 5;
+const PARALLEL_REQUESTS: usize = 5;
+
+const NETWORK: Network = Network::Signet;
+const EXTERNAL_DESC: &str = "wpkh(tprv8ZgxMBicQKsPdy6LMhUtFHAgpocR8GC6QmwMSFpZs7h6Eziw3SpThFfczTDh5rW2krkqffa11UpX3XkeTTB2FvzZKWXqPY54Y6Rq4AQ5R8L/84'/1'/0'/0/*)";
+const INTERNAL_DESC: &str = "wpkh(tprv8ZgxMBicQKsPdy6LMhUtFHAgpocR8GC6QmwMSFpZs7h6Eziw3SpThFfczTDh5rW2krkqffa11UpX3XkeTTB2FvzZKWXqPY54Y6Rq4AQ5R8L/84'/1'/0'/1/*)";
+const ESPLORA_URL: &str = "http://signet.bitcoindevkit.net";
+
+fn main() -> Result<(), anyhow::Error> {
+    let mut store = Store::new(DB_PATH, "wallet1".to_string())?;
+
+    let wallet_opt = Wallet::load()
+        .descriptor(KeychainKind::External, Some(EXTERNAL_DESC))
+        .descriptor(KeychainKind::Internal, Some(INTERNAL_DESC))
+        .extract_keys()
+        .check_network(NETWORK)
+        .load_wallet(&mut store)?;
+    let mut wallet = match wallet_opt {
+        Some(wallet) => wallet,
+        None => Wallet::create(EXTERNAL_DESC, INTERNAL_DESC)
+            .network(NETWORK)
+            .create_wallet(&mut store)?,
+    };
+
+    let address = wallet.next_unused_address(KeychainKind::External);
+    wallet.persist(&mut store)?;
+    println!(
+        "Next unused address: ({}) {}",
+        address.index, address.address
+    );
+
+    let balance = wallet.balance();
+    println!("Wallet balance before syncing: {}", balance.total());
+
+    print!("Syncing...");
+    let client = esplora_client::Builder::new(ESPLORA_URL).build_blocking();
+
+    let request = wallet.start_full_scan().inspect({
+        let mut stdout = std::io::stdout();
+        let mut once = BTreeSet::<KeychainKind>::new();
+        move |keychain, spk_i, _| {
+            if once.insert(keychain) {
+                print!("\nScanning keychain [{:?}] ", keychain);
+            }
+            print!(" {:<3}", spk_i);
+            stdout.flush().expect("must flush")
+        }
+    });
+
+    let update = client.full_scan(request, STOP_GAP, PARALLEL_REQUESTS)?;
+
+    wallet.apply_update(update)?;
+    wallet.persist(&mut store)?;
+    println!();
+
+    let balance = wallet.balance();
+    println!("Wallet balance after syncing: {}", balance.total());
+
+    if balance.total() < SEND_AMOUNT {
+        println!(
+            "Please send at least {} to the receiving address",
+            SEND_AMOUNT
+        );
+        std::process::exit(0);
+    }
+
+    let mut tx_builder = wallet.build_tx();
+    tx_builder.add_recipient(address.script_pubkey(), SEND_AMOUNT);
+
+    let mut psbt = tx_builder.finish()?;
+    let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
+    assert!(finalized);
+
+    let tx = psbt.extract_tx()?;
+    client.broadcast(&tx)?;
+    println!("Tx broadcasted! Txid: {}", tx.compute_txid());
+
+    Ok(())
+}
diff --git a/examples/example_wallet_rpc_redb/Cargo.toml b/examples/example_wallet_rpc_redb/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "example_wallet_rpc_redb"
+version = "0.1.0"
+edition = "2024"
+authors.workspace = true
+
+[dependencies]
+bdk_wallet = { version = "2.0.0" }
+bdk_bitcoind_rpc = { version = "0.20.0" }
+
+anyhow = "1"
+clap = { version = "4.5.17", features = ["derive", "env"] }
+ctrlc = "3.4.6"
+bdk_redb = { git = "https://github.com/110CodingP/bdk_redb" }
diff --git a/examples/example_wallet_rpc_redb/README.md b/examples/example_wallet_rpc_redb/README.md
@@ -0,0 +1,36 @@
+# Wallet RPC Example
+
+```
+$ cargo run --bin example_wallet_rpc -- --help
+
+Bitcoind RPC example using `bdk_wallet::Wallet`
+
+Usage: example_wallet_rpc [OPTIONS] <DESCRIPTOR> [CHANGE_DESCRIPTOR]
+
+Arguments:
+  <DESCRIPTOR>         Wallet descriptor [env: DESCRIPTOR=]
+  [CHANGE_DESCRIPTOR]  Wallet change descriptor [env: CHANGE_DESCRIPTOR=]
+
+Options:
+      --start-height <START_HEIGHT>  Earliest block height to start sync from [env: START_HEIGHT=] [default: 0]
+
+      --network <NETWORK>            Bitcoin network to connect to [env: BITCOIN_NETWORK=] [default: regtest]
+
+      --db-path <DB_PATH>            Where to store wallet data [env: BDK_DB_PATH=] [default: .bdk_wallet_rpc_example.db]
+
+      --url <URL>                    RPC URL [env: RPC_URL=] [default: 127.0.0.1:18443]
+
+      --rpc-cookie <RPC_COOKIE>      RPC auth cookie file [env: RPC_COOKIE=]
+
+      --rpc-user <RPC_USER>          RPC auth username [env: RPC_USER=]
+
+      --rpc-pass <RPC_PASS>          RPC auth password [env: RPC_PASS=]
+      
+      --wallet-name <WALLET_NAME>    Name of wallet [env: WALLET_NAME=] [default: wallet1]
+
+  -h, --help                         Print help
+  
+  -V, --version                      Print version
+
+```
+
diff --git a/examples/example_wallet_rpc_redb/src/main.rs b/examples/example_wallet_rpc_redb/src/main.rs
@@ -0,0 +1,210 @@
+use bdk_bitcoind_rpc::{
+    bitcoincore_rpc::{Auth, Client, RpcApi},
+    Emitter, MempoolEvent,
+};
+
+use bdk_redb::Store;
+use bdk_wallet::{
+    bitcoin::{Block, Network},
+    KeychainKind, Wallet,
+};
+use clap::{self, Parser};
+use std::{
+    path::PathBuf,
+    sync::{mpsc::sync_channel, Arc},
+    thread::spawn,
+    time::Instant,
+};
+
+
+/// Bitcoind RPC example using `bdk_wallet::Wallet`.
+///
+/// This syncs the chain block-by-block and prints the current balance, transaction count and UTXO
+/// count.
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+#[clap(propagate_version = true)]
+pub struct Args {
+    /// Wallet descriptor
+    #[clap(env = "DESCRIPTOR")]
+    pub descriptor: String,
+    /// Wallet change descriptor
+    #[clap(env = "CHANGE_DESCRIPTOR")]
+    pub change_descriptor: Option<String>,
+    /// Earliest block height to start sync from
+    #[clap(env = "START_HEIGHT", long, default_value = "0")]
+    pub start_height: u32,
+    /// Bitcoin network to connect to
+    #[clap(env = "BITCOIN_NETWORK", long, default_value = "regtest")]
+    pub network: Network,
+    /// Where to store wallet data
+    #[clap(
+        env = "BDK_DB_PATH",
+        long,
+        default_value = ".bdk_wallet_rpc_example.db"
+    )]
+    pub db_path: PathBuf,
+
+    /// RPC URL
+    #[clap(env = "RPC_URL", long, default_value = "127.0.0.1:18443")]
+    pub url: String,
+    /// RPC auth cookie file
+    #[clap(env = "RPC_COOKIE", long)]
+    pub rpc_cookie: Option<PathBuf>,
+    /// RPC auth username
+    #[clap(env = "RPC_USER", long)]
+    pub rpc_user: Option<String>,
+    /// RPC auth password
+    #[clap(env = "RPC_PASS", long)]
+    pub rpc_pass: Option<String>,
+    /// Wallet name
+    #[clap(env = "WALLET_NAME", long, default_value = "wallet1")]
+    pub wallet_name: String,
+}
+
+impl Args {
+    fn client(&self) -> anyhow::Result<Client> {
+        Ok(Client::new(
+            &self.url,
+            match (&self.rpc_cookie, &self.rpc_user, &self.rpc_pass) {
+                (None, None, None) => Auth::None,
+                (Some(path), _, _) => Auth::CookieFile(path.clone()),
+                (_, Some(user), Some(pass)) => Auth::UserPass(user.clone(), pass.clone()),
+                (_, Some(_), None) => panic!("rpc auth: missing rpc_pass"),
+                (_, None, Some(_)) => panic!("rpc auth: missing rpc_user"),
+            },
+        )?)
+    }
+}
+
+#[derive(Debug)]
+enum Emission {
+    SigTerm,
+    Block(bdk_bitcoind_rpc::BlockEvent<Block>),
+    Mempool(MempoolEvent),
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = Args::parse();
+
+    let rpc_client = Arc::new(args.client()?);
+    println!(
+        "Connected to Bitcoin Core RPC at {:?}",
+        rpc_client.get_blockchain_info().unwrap()
+    );
+
+    let start_load_wallet = Instant::now();
+    let mut store =
+        Store::new(args.db_path, args.wallet_name)?;
+    let wallet_opt = Wallet::load()
+        .descriptor(KeychainKind::External, Some(args.descriptor.clone()))
+        .descriptor(KeychainKind::Internal, args.change_descriptor.clone())
+        .extract_keys()
+        .check_network(args.network)
+        .load_wallet(&mut store)?;
+    let mut wallet = match wallet_opt {
+        Some(wallet) => wallet,
+        None => match &args.change_descriptor {
+            Some(change_desc) => Wallet::create(args.descriptor.clone(), change_desc.clone())
+                .network(args.network)
+                .create_wallet(&mut store)?,
+            None => Wallet::create_single(args.descriptor.clone())
+                .network(args.network)
+                .create_wallet(&mut store)?,
+        },
+    };
+    println!(
+        "Loaded wallet in {}s",
+        start_load_wallet.elapsed().as_secs_f32()
+    );
+
+    let balance = wallet.balance();
+    println!("Wallet balance before syncing: {}", balance.total());
+
+    let wallet_tip = wallet.latest_checkpoint();
+    println!(
+        "Wallet tip: {} at height {}",
+        wallet_tip.hash(),
+        wallet_tip.height()
+    );
+
+    let (sender, receiver) = sync_channel::<Emission>(21);
+
+    let signal_sender = sender.clone();
+    let _ = ctrlc::set_handler(move || {
+        signal_sender
+            .send(Emission::SigTerm)
+            .expect("failed to send sigterm")
+    });
+
+    let mut emitter = Emitter::new(
+        rpc_client,
+        wallet_tip,
+        args.start_height,
+        wallet
+            .transactions()
+            .filter(|tx| tx.chain_position.is_unconfirmed()),
+    );
+    spawn(move || -> Result<(), anyhow::Error> {
+        while let Some(emission) = emitter.next_block()? {
+            sender.send(Emission::Block(emission))?;
+        }
+        sender.send(Emission::Mempool(emitter.mempool()?))?;
+        Ok(())
+    });
+
+    let mut blocks_received = 0_usize;
+    for emission in receiver {
+        match emission {
+            Emission::SigTerm => {
+                println!("Sigterm received, exiting...");
+                break;
+            }
+            Emission::Block(block_emission) => {
+                blocks_received += 1;
+                let height = block_emission.block_height();
+                let hash = block_emission.block_hash();
+                let connected_to = block_emission.connected_to();
+                let start_apply_block = Instant::now();
+                wallet.apply_block_connected_to(&block_emission.block, height, connected_to)?;
+                wallet.persist(&mut store)?;
+                let elapsed = start_apply_block.elapsed().as_secs_f32();
+                println!(
+                    "Applied block {} at height {} in {}s",
+                    hash, height, elapsed
+                );
+            }
+            Emission::Mempool(event) => {
+                let start_apply_mempool = Instant::now();
+                wallet.apply_evicted_txs(event.evicted_ats());
+                wallet.apply_unconfirmed_txs(event.new_txs);
+                wallet.persist(&mut store)?;
+                println!(
+                    "Applied unconfirmed transactions in {}s",
+                    start_apply_mempool.elapsed().as_secs_f32()
+                );
+                break;
+            }
+        }
+    }
+    let wallet_tip_end = wallet.latest_checkpoint();
+    let balance = wallet.balance();
+    println!(
+        "Synced {} blocks in {}s",
+        blocks_received,
+        start_load_wallet.elapsed().as_secs_f32(),
+    );
+    println!(
+        "Wallet tip is '{}:{}'",
+        wallet_tip_end.height(),
+        wallet_tip_end.hash()
+    );
+    println!("Wallet balance is {}", balance.total());
+    println!(
+        "Wallet has {} transactions and {} utxos",
+        wallet.transactions().count(),
+        wallet.list_unspent().count()
+    );
+
+    Ok(())
+}
