bft-crdt-experiment/side-node/src/bitcoin/driver/htlc.rs

use crate::bitcoin::{self, driver};
use bdk::wallet::AddressIndex::New;
use bdk::SignOptions;

pub(crate) async fn run() -> anyhow::Result<()> {
    tracing::info!("starting htlc flow");
    let (dave, sammy) = driver::setup().await?;
    tracing::info!("syncing dave wallet");
    let _ = dave.sync();
    tracing::info!("syncing samy wallet");
    let _ = sammy.sync();

    // format a new commitment transaction like in Lightning
    let mut commitment_builder = dave.wallet.build_tx();
    let amount = 500;
    let recipient = sammy.wallet.get_address(New)?.script_pubkey();

    // Feed it 500 sats, a redeem identity, a hashlock, a refund timelock, and a refund identity
    //
    let htlc = bitcoin::htlc::Htlc::new(
        dave.external_public_key,
        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".to_string(),
        100,
        sammy.external_public_key,
    );

    let htlc_descriptor = htlc.to_miniscript_descriptor();
    tracing::info!("descriptor: {}", htlc_descriptor);

    commitment_builder.add_recipient(recipient, amount);
    commitment_builder.enable_rbf();
    let (psbt, _) = commitment_builder
        .finish()
        .expect("unable to build commitment");

    // sign the commitment transaction
    let mut dave_psbt = dave.sign(&mut psbt.clone(), false)?;
    let sammy_psbt = sammy.sign(&mut psbt.clone(), false)?;

    dave_psbt
        .combine(sammy_psbt)
        .expect("problem combining bitcoin PSBTs"); // these guys love mutability

    let finalized = dave
        .wallet
        .finalize_psbt(&mut dave_psbt, SignOptions::default())
        .expect("couldn't finalize");

    assert!(finalized);
    let tx = dave_psbt.extract_tx();

    let _ = dave.broadcast(&tx)?;

    let _ = sammy.sync();
    let _ = sammy.wallet.get_balance();
    Ok(())
}