Add probing service

Introduce a background probing service that periodically dispatches
probes to improve the scorer's liquidity estimates. Includes two
built-in strategies.

Author: randomlogin

examples/bip157_wallet_sync.rs

@@ -0,0 +1,178 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+//! BIP157 wallet sync experiment.
+//!
+//! Creates a BDK wallet using the same setup as ldk-node (BIP84 / P2WPKH, derived from a BIP39
+//! mnemonic), then syncs it against a local signet Bitcoin node via compact block filters.
+//!
+//! # Prerequisites
+//!
+//! Your bitcoind must be started with compact filter support:
+//!   -blockfilterindex=1 -peerblockfilters=1
+//!
+//! # Usage
+//!
+//! First run — generates a fresh mnemonic and prints the receive address:
+//!   cargo run --example bip157_wallet_sync
+//!
+//! Subsequent runs — reuse the same wallet:
+//!   MNEMONIC="word1 word2 ..." cargo run --example bip157_wallet_sync
+//!
+//! For faster sync, set a recent checkpoint (query your node first):
+//!   bitcoin-cli -signet getblockcount
+//!   bitcoin-cli -signet getbestblockhash
+//! Then update CHECKPOINT_HEIGHT / CHECKPOINT_HASH below.
+
+use bdk_chain::BlockId;
+use bdk_wallet::template::Bip84;
+use bdk_wallet::{KeychainKind, Update, Wallet};
+use bip157::chain::{BlockHeaderChanges, ChainState};
+use bip157::{Builder, Client, Event, HeaderCheckpoint, Magic, Network, ScriptBuf, TrustedPeer};
+use bip39::Mnemonic;
+use bitcoin::bip32::Xpriv;
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+// Kyoto speaks the Bitcoin P2P protocol — no RPC username/password needed.
+// These are the known peers of the mutiny signet network.
+const REMOTE_PEER: &str = "45.79.52.207:38333";
+const LOCAL_PEER: &str = "127.0.0.1:38333";
+
+/// Signet genesis block. Replace with a recent block for faster sync — any block before your
+/// wallet's first transaction will do.
+const CHECKPOINT_HEIGHT: u32 = 2919361;
+const CHECKPOINT_HASH: &str = "000000cdac0592cf9a50dcae2ca91854801d7bb6d12affa5a0cbb4b378fbab1d";
+
+/// How many addresses to pre-derive and watch per keychain (external + internal).
+const LOOKAHEAD: u32 = 20;
+
+#[tokio::main]
+async fn main() {
+	// ── Wallet ────────────────────────────────────────────────────────────────
+
+	let mnemonic = match std::env::var("MNEMONIC") {
+		Ok(s) => Mnemonic::parse(s).expect("Invalid mnemonic in MNEMONIC env var"),
+		Err(_) => {
+			let m = Mnemonic::generate(12).unwrap();
+			println!("Generated mnemonic (save this for next run):\n  {m}\n");
+			m
+		},
+	};
+
+	let seed = mnemonic.to_seed("");
+
+	// Identical derivation to ldk-node (see builder.rs):
+	//   Xpriv::new_master → Bip84(xprv, External) + Bip84(xprv, Internal)
+	let xprv = Xpriv::new_master(bitcoin::Network::Signet, &seed).unwrap();
+	let descriptor = Bip84(xprv, KeychainKind::External);
+	let change_descriptor = Bip84(xprv, KeychainKind::Internal);
+
+	let mut wallet = Wallet::create(descriptor, change_descriptor)
+		.network(bitcoin::Network::Signet)
+		.create_wallet_no_persist()
+		.unwrap();
+
+	// Reveal the first receive address and collect scripts to watch.
+	let receive_addr = wallet.reveal_next_address(KeychainKind::External);
+	println!("Receive address: {}\n", receive_addr.address);
+	println!("Send some signet BTC to it, then this example will detect it.\n");
+
+	let scripts: HashSet<ScriptBuf> = (0..LOOKAHEAD)
+		.flat_map(|i| {
+			[
+				wallet.peek_address(KeychainKind::External, i).address.script_pubkey(),
+				wallet.peek_address(KeychainKind::Internal, i).address.script_pubkey(),
+			]
+		})
+		.collect();
+
+	println!("Watching {} scripts across {} lookahead addresses.", scripts.len(), LOOKAHEAD);
+
+	// ── Kyoto ─────────────────────────────────────────────────────────────────
+
+	// Mutiny signet uses a custom signetchallenge; its P2P magic differs from the default signet.
+	// Computed as SHA256d("bitcoin signet:" || compact_size(len) || challenge)[0:4]
+	// challenge = 512102f7561d208dd9ae99bf497273e16f389bdbd6c4742ddb8e6b216e64fa2928ad8f51ae
+	let mutiny_magic = Magic::from_bytes([0xa5, 0xdf, 0x2d, 0xcb]);
+
+	let remote_peer: TrustedPeer = REMOTE_PEER.parse::<std::net::SocketAddr>().unwrap().into();
+	let local_peer: TrustedPeer = LOCAL_PEER.parse::<std::net::SocketAddr>().unwrap().into();
+
+	let checkpoint = HeaderCheckpoint::new(CHECKPOINT_HEIGHT, CHECKPOINT_HASH.parse().unwrap());
+
+	// data_dir persists the address book so that on subsequent runs kyoto does not fall back to
+	// DNS seeds (which return default-signet peers, not mutiny-signet peers).
+	let data_dir = PathBuf::from("/tmp/bip157-mutiny-signet");
+
+	let (node, client) = Builder::new(Network::Signet)
+		.add_peer(remote_peer)
+		.add_peer(local_peer)
+		.data_dir(data_dir)
+		.chain_state(ChainState::Checkpoint(checkpoint))
+		.custom_magic(mutiny_magic)
+		.build();
+
+	tokio::task::spawn(async move { node.run().await });
+
+	let Client { requester, mut info_rx, mut warn_rx, mut event_rx } = client;
+
+	// ── Event loop ────────────────────────────────────────────────────────────
+
+	loop {
+		tokio::select! {
+			event = event_rx.recv() => {
+				let Some(event) = event else { break };
+				match event {
+					// Advance BDK's local chain tip for every connected header, so
+					// confirmation depths are correct even for non-matching blocks.
+					Event::ChainUpdate(BlockHeaderChanges::Connected(header)) => {
+						let cp = wallet.latest_checkpoint().insert(BlockId {
+							height: header.height,
+							hash: header.block_hash(),
+						});
+						wallet.apply_update(Update { chain: Some(cp), ..Default::default() }).unwrap();
+					},
+
+					// Check each block's compact filter against our watched scripts.
+					Event::IndexedFilter(filter) => {
+						if filter.contains_any(scripts.iter()) {
+							println!("Filter match at height {}! Downloading block...",filter.height());
+							match requester.get_block(filter.block_hash()).await {
+								Ok(indexed_block) => {
+									wallet.apply_block_events(&indexed_block.block, indexed_block.height).unwrap();
+									let b = wallet.balance();
+									println!( "  Balance: confirmed={} trusted_pending={}", b.confirmed, b.trusted_pending,);
+								},
+								Err(e) => eprintln!("  Failed to fetch block: {e:?}"),
+							}
+						}
+					},
+
+					// Caught up to the current tip — print balance and keep watching
+					// for new blocks arriving on the network.
+					Event::FiltersSynced(update) => {
+						let b = wallet.balance();
+						println!(
+							"\nCaught up to height {}. Balance: confirmed={} trusted_pending={}",
+							update.tip().height,
+							b.confirmed,
+							b.trusted_pending,
+						);
+						println!("Watching for new blocks... (Ctrl+C to stop)\n");
+					},
+
+					_ => {},
+				}
+			},
+			Some(info) = info_rx.recv() => println!("[kyoto] {info}"),
+			Some(warn) = warn_rx.recv() => eprintln!("[kyoto] {warn}"),
+		}
+	}
+
+	let _ = requester.shutdown();
+}