140 lines
4.6 KiB
Rust
140 lines
4.6 KiB
Rust
use std::{collections::BTreeSet, fs, io::Write, str::FromStr};
|
|
|
|
use bdk::keys::bip39::Mnemonic;
|
|
use bdk_esplora::{esplora_client, EsploraAsyncExt};
|
|
use bdk_wallet::{
|
|
bitcoin::{Address, Amount, Network, Script},
|
|
chain::ConfirmationTimeHeightAnchor,
|
|
keys::{DerivableKey, ExtendedKey},
|
|
wallet::AddressInfo,
|
|
KeychainKind, SignOptions, Wallet,
|
|
};
|
|
|
|
use bdk_sqlite::{rusqlite::Connection, Store};
|
|
|
|
use crate::utils;
|
|
|
|
const STOP_GAP: usize = 50;
|
|
const PARALLEL_REQUESTS: usize = 5;
|
|
|
|
pub(crate) fn build_send_tx(
|
|
mut wallet: Wallet,
|
|
faucet_address: Address,
|
|
amount: Amount,
|
|
) -> Result<bitcoin::Transaction, anyhow::Error> {
|
|
let mut tx_builder = wallet.build_tx();
|
|
tx_builder
|
|
.add_recipient(faucet_address.script_pubkey(), amount)
|
|
.enable_rbf();
|
|
let mut psbt = tx_builder.finish()?;
|
|
let finalized = wallet.sign(&mut psbt, SignOptions::default())?;
|
|
assert!(finalized);
|
|
let tx = psbt.extract_tx()?;
|
|
Ok(tx)
|
|
}
|
|
|
|
pub(crate) async fn sync(
|
|
wallet: &mut Wallet,
|
|
db: &mut Store<KeychainKind, ConfirmationTimeHeightAnchor>,
|
|
) -> Result<esplora_client::AsyncClient, anyhow::Error> {
|
|
print!("Syncing...");
|
|
let client = esplora_client::Builder::new("https://mutinynet.com/api")
|
|
.build_async()
|
|
.expect("couldn't build esplora client");
|
|
fn generate_inspect(kind: KeychainKind) -> impl FnMut(u32, &Script) + Send + Sync + 'static {
|
|
let mut once = Some(());
|
|
let mut stdout = std::io::stdout();
|
|
move |spk_i, _| {
|
|
match once.take() {
|
|
Some(_) => print!("\nScanning keychain [{:?}]", kind),
|
|
None => print!(" {:<3}", spk_i),
|
|
};
|
|
stdout.flush().expect("must flush");
|
|
}
|
|
}
|
|
let request = wallet
|
|
.start_full_scan()
|
|
.inspect_spks_for_all_keychains({
|
|
let mut once = BTreeSet::<KeychainKind>::new();
|
|
move |keychain, spk_i, _| {
|
|
match once.insert(keychain) {
|
|
true => print!("\nScanning keychain [{:?}]", keychain),
|
|
false => print!(" {:<3}", spk_i),
|
|
}
|
|
std::io::stdout().flush().expect("must flush")
|
|
}
|
|
})
|
|
.inspect_spks_for_keychain(
|
|
KeychainKind::External,
|
|
generate_inspect(KeychainKind::External),
|
|
)
|
|
.inspect_spks_for_keychain(
|
|
KeychainKind::Internal,
|
|
generate_inspect(KeychainKind::Internal),
|
|
);
|
|
let mut update = client
|
|
.full_scan(request, STOP_GAP, PARALLEL_REQUESTS)
|
|
.await?;
|
|
let now = std::time::UNIX_EPOCH.elapsed().unwrap().as_secs();
|
|
let _ = update.graph_update.update_last_seen_unconfirmed(now);
|
|
wallet.apply_update(update)?;
|
|
if let Some(changeset) = wallet.take_staged() {
|
|
db.write(&changeset)?;
|
|
}
|
|
println!();
|
|
Ok(client)
|
|
}
|
|
|
|
pub(crate) fn next_unused_address(
|
|
wallet: &mut Wallet,
|
|
db: &mut Store<KeychainKind, ConfirmationTimeHeightAnchor>,
|
|
) -> Result<AddressInfo, anyhow::Error> {
|
|
let address = wallet.next_unused_address(KeychainKind::External);
|
|
if let Some(changeset) = wallet.take_staged() {
|
|
db.write(&changeset)?;
|
|
}
|
|
println!("Generated Address: {}", address);
|
|
Ok(address)
|
|
}
|
|
|
|
pub(crate) fn create_wallet(
|
|
name: &str,
|
|
) -> anyhow::Result<(Wallet, Store<KeychainKind, ConfirmationTimeHeightAnchor>)> {
|
|
let keys_dir = utils::home(name);
|
|
|
|
let mnemonic_path = crate::utils::side_paths(keys_dir).1; // TODO: this tuple stinks
|
|
let mnemonic_words = fs::read_to_string(mnemonic_path).expect("couldn't read bitcoin key file");
|
|
|
|
println!("Creating wallet from mnemonic: {mnemonic_words}");
|
|
let mnemonic = Mnemonic::parse(mnemonic_words).unwrap();
|
|
|
|
// Generate the extended key
|
|
let xkey: ExtendedKey = mnemonic
|
|
.into_extended_key()
|
|
.expect("couldn't turn mnemonic into xkey");
|
|
|
|
let xprv = xkey
|
|
.into_xprv(Network::Signet)
|
|
.expect("problem converting xkey to xprv")
|
|
.to_string();
|
|
|
|
println!("Setting up esplora database for {name}");
|
|
|
|
let db_path = format!("/tmp/{name}-bdk-esplora-async-example.sqlite");
|
|
let conn = Connection::open(db_path)?;
|
|
let mut db = Store::new(conn)?;
|
|
let external_descriptor = format!("wpkh({xprv}/84'/1'/0'/0/*)");
|
|
let internal_descriptor = format!("wpkh({xprv}/84'/1'/0'/1/*)");
|
|
let changeset = db.read().expect("couldn't read esplora database");
|
|
|
|
let wallet = Wallet::new_or_load(
|
|
&external_descriptor,
|
|
&internal_descriptor,
|
|
changeset,
|
|
Network::Signet,
|
|
)
|
|
.expect("problem setting up wallet");
|
|
|
|
Ok((wallet, db))
|
|
}
|