mirror of
https://github.com/comit-network/xmr-btc-swap.git
synced 2024-10-01 05:45:40 +00:00
a0ef1f96ec
The bitcoind wallet required the user to run a bitcoind node. It was replaced with a bdk wallet which allows the user to connect to an electrum instance hosted remotely. An electrum and bitcoind testcontainer were created to the test the bdk wallet. The electrum container reads the blockdata from the bitcoind testcontainer through a shared volume. bitcoind-harness was removed as bitcoind initialisation code was moved into test_utils. The bdk wallet differs from the bitcoind wallet in that it needs to be manually synced with an electrum node. We synchronise the wallet once upon initialisation to prevent a potentially long running blocking task from interrupting protocol execution. The electrum HTTP API was used to get the latest block height and the transaction block height as this functionality was not present in the bdk wallet API or it required the bdk wallet to be re-synced to get an up to date value.
96 lines
2.8 KiB
Rust
96 lines
2.8 KiB
Rust
use crate::bitcoin::{
|
|
build_shared_output_descriptor, Address, Amount, BuildTxLockPsbt, GetNetwork, PublicKey,
|
|
Transaction, TX_FEE,
|
|
};
|
|
use ::bitcoin::{util::psbt::PartiallySignedTransaction, OutPoint, TxIn, TxOut, Txid};
|
|
use anyhow::Result;
|
|
use miniscript::{Descriptor, NullCtx};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct TxLock {
|
|
inner: PartiallySignedTransaction,
|
|
pub(in crate::bitcoin) output_descriptor: Descriptor<::bitcoin::PublicKey>,
|
|
}
|
|
|
|
impl TxLock {
|
|
pub async fn new<W>(wallet: &W, amount: Amount, A: PublicKey, B: PublicKey) -> Result<Self>
|
|
where
|
|
W: BuildTxLockPsbt + GetNetwork,
|
|
{
|
|
let lock_output_descriptor = build_shared_output_descriptor(A.0, B.0);
|
|
let address = lock_output_descriptor
|
|
.address(wallet.get_network().await, NullCtx)
|
|
.expect("can derive address from descriptor");
|
|
|
|
let psbt = wallet.build_tx_lock_psbt(address, amount).await?;
|
|
|
|
Ok(Self {
|
|
inner: psbt,
|
|
output_descriptor: lock_output_descriptor,
|
|
})
|
|
}
|
|
|
|
pub fn lock_amount(&self) -> Amount {
|
|
Amount::from_sat(self.inner.clone().extract_tx().output[self.lock_output_vout()].value)
|
|
}
|
|
|
|
pub fn txid(&self) -> Txid {
|
|
self.inner.clone().extract_tx().txid()
|
|
}
|
|
|
|
pub fn as_outpoint(&self) -> OutPoint {
|
|
// This is fine because a transaction that has that many outputs is not
|
|
// realistic
|
|
#[allow(clippy::cast_possible_truncation)]
|
|
OutPoint::new(self.txid(), self.lock_output_vout() as u32)
|
|
}
|
|
|
|
/// Retreive the index of the locked output in the transaction outputs
|
|
/// vector
|
|
fn lock_output_vout(&self) -> usize {
|
|
self.inner
|
|
.clone()
|
|
.extract_tx()
|
|
.output
|
|
.iter()
|
|
.position(|output| {
|
|
output.script_pubkey == self.output_descriptor.script_pubkey(NullCtx)
|
|
})
|
|
.expect("transaction contains lock output")
|
|
}
|
|
|
|
pub fn build_spend_transaction(
|
|
&self,
|
|
spend_address: &Address,
|
|
sequence: Option<u32>,
|
|
) -> Transaction {
|
|
let previous_output = self.as_outpoint();
|
|
|
|
let tx_in = TxIn {
|
|
previous_output,
|
|
script_sig: Default::default(),
|
|
sequence: sequence.unwrap_or(0xFFFF_FFFF),
|
|
witness: Vec::new(),
|
|
};
|
|
|
|
let tx_out = TxOut {
|
|
value: self.inner.clone().extract_tx().output[self.lock_output_vout()].value - TX_FEE,
|
|
script_pubkey: spend_address.script_pubkey(),
|
|
};
|
|
|
|
Transaction {
|
|
version: 2,
|
|
lock_time: 0,
|
|
input: vec![tx_in],
|
|
output: vec![tx_out],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<TxLock> for PartiallySignedTransaction {
|
|
fn from(from: TxLock) -> Self {
|
|
from.inner
|
|
}
|
|
}
|