Add TxBuilder APIs

bdk-ffi/src/bdk.udl

@@ -75,6 +75,8 @@ interface CreateTxError {
   UnknownUtxo(string outpoint);
   MissingNonWitnessUtxo(string outpoint);
   MiniscriptPsbt(string error_message);
+  PushBytesError();
+  LockTimeConversionError();
 };
 
 [Error]
@@ -709,6 +711,12 @@ interface TxBuilder {
 
   TxBuilder set_exact_sequence(u32 nsequence);
 
+  TxBuilder add_data(sequence<u8> data);
+
+  TxBuilder current_height(u32 height);
+
+  TxBuilder nlocktime(LockTime locktime);
+
   [Throws=CreateTxError]
   Psbt finish([ByRef] Wallet wallet);
 };
@@ -718,6 +726,10 @@ interface BumpFeeTxBuilder {
 
   BumpFeeTxBuilder set_exact_sequence(u32 nsequence);
 
+  BumpFeeTxBuilder current_height(u32 height);
+
+  BumpFeeTxBuilder nlocktime(LockTime locktime);
+
   [Throws=CreateTxError]
   Psbt finish([ByRef] Wallet wallet);
 };

bdk-ffi/src/error.rs

@@ -1,5 +1,6 @@
 use bitcoin_ffi::OutPoint;
 
+use bdk_core::bitcoin::script::PushBytesError;
 use bdk_electrum::electrum_client::Error as BdkElectrumError;
 use bdk_esplora::esplora_client::{Error as BdkEsploraError, Error};
 use bdk_wallet::bitcoin::address::ParseError as BdkParseError;
@@ -195,6 +196,12 @@ pub enum CreateTxError {
 
     #[error("miniscript psbt error: {error_message}")]
     MiniscriptPsbt { error_message: String },
+
+    #[error("attempt to prepare too many bytes to be pushed into script")]
+    PushBytesError,
+
+    #[error("invalid lock time value")]
+    LockTimeConversionError,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -951,6 +958,12 @@ impl From<BdkCreateTxError> for CreateTxError {
     }
 }
 
+impl From<PushBytesError> for CreateTxError {
+    fn from(_: PushBytesError) -> Self {
+        CreateTxError::PushBytesError
+    }
+}
+
 impl From<BdkCreateWithPersistError<chain::rusqlite::Error>> for CreateWithPersistError {
     fn from(error: BdkCreateWithPersistError<chain::rusqlite::Error>) -> Self {
         match error {

bdk-ffi/src/tx_builder.rs

@@ -1,20 +1,23 @@
 use crate::bitcoin::Psbt;
 use crate::error::CreateTxError;
-use crate::types::ScriptAmount;
+use crate::types::{LockTime, ScriptAmount};
 use crate::wallet::Wallet;
 
-use bdk_wallet::KeychainKind;
 use bitcoin_ffi::{Amount, FeeRate, Script};
 
+use bdk_wallet::bitcoin::absolute::LockTime as BdkLockTime;
 use bdk_wallet::bitcoin::amount::Amount as BdkAmount;
+use bdk_wallet::bitcoin::script::PushBytesBuf;
 use bdk_wallet::bitcoin::Psbt as BdkPsbt;
 use bdk_wallet::bitcoin::ScriptBuf as BdkScriptBuf;
 use bdk_wallet::bitcoin::{OutPoint, Sequence, Txid};
 use bdk_wallet::ChangeSpendPolicy;
+use bdk_wallet::KeychainKind;
 
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::convert::{TryFrom, TryInto};
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -33,6 +36,9 @@ pub struct TxBuilder {
     pub(crate) drain_wallet: bool,
     pub(crate) drain_to: Option<BdkScriptBuf>,
     pub(crate) sequence: Option<u32>,
+    pub(crate) data: Vec<u8>,
+    pub(crate) current_height: Option<u32>,
+    pub(crate) locktime: Option<LockTime>,
 }
 
 impl TxBuilder {
@@ -51,6 +57,9 @@ impl TxBuilder {
             drain_wallet: false,
             drain_to: None,
             sequence: None,
+            data: Vec::new(),
+            current_height: None,
+            locktime: None,
         }
     }
 
@@ -193,6 +202,27 @@ impl TxBuilder {
         })
     }
 
+    pub(crate) fn add_data(&self, data: Vec<u8>) -> Arc<Self> {
+        Arc::new(TxBuilder {
+            data,
+            ..self.clone()
+        })
+    }
+
+    pub(crate) fn current_height(&self, height: u32) -> Arc<Self> {
+        Arc::new(TxBuilder {
+            current_height: Some(height),
+            ..self.clone()
+        })
+    }
+
+    pub(crate) fn nlocktime(&self, locktime: LockTime) -> Arc<Self> {
+        Arc::new(TxBuilder {
+            locktime: Some(locktime),
+            ..self.clone()
+        })
+    }
+
     pub(crate) fn finish(&self, wallet: &Arc<Wallet>) -> Result<Arc<Psbt>, CreateTxError> {
         // TODO: I had to change the wallet here to be mutable. Why is that now required with the 1.0 API?
         let mut wallet = wallet.get_wallet();
@@ -237,6 +267,18 @@ impl TxBuilder {
         if let Some(sequence) = self.sequence {
             tx_builder.set_exact_sequence(Sequence(sequence));
         }
+        if !&self.data.is_empty() {
+            let push_bytes = PushBytesBuf::try_from(self.data.clone())?;
+            tx_builder.add_data(&push_bytes);
+        }
+        if let Some(height) = self.current_height {
+            tx_builder.current_height(height);
+        }
+        // let bdk_locktime = locktime.try_into().map_err(CreateTxError::LockTimeConversionError)?;
+        if let Some(locktime) = &self.locktime {
+            let bdk_locktime: BdkLockTime = locktime.try_into()?;
+            tx_builder.nlocktime(bdk_locktime);
+        }
 
         let psbt = tx_builder.finish().map_err(CreateTxError::from)?;
 
@@ -249,14 +291,18 @@ pub(crate) struct BumpFeeTxBuilder {
     pub(crate) txid: String,
     pub(crate) fee_rate: Arc<FeeRate>,
     pub(crate) sequence: Option<u32>,
+    pub(crate) current_height: Option<u32>,
+    pub(crate) locktime: Option<LockTime>,
 }
 
 impl BumpFeeTxBuilder {
     pub(crate) fn new(txid: String, fee_rate: Arc<FeeRate>) -> Self {
-        Self {
+        BumpFeeTxBuilder {
             txid,
             fee_rate,
             sequence: None,
+            current_height: None,
+            locktime: None,
         }
     }
 
@@ -267,6 +313,20 @@ impl BumpFeeTxBuilder {
         })
     }
 
+    pub(crate) fn current_height(&self, height: u32) -> Arc<Self> {
+        Arc::new(BumpFeeTxBuilder {
+            current_height: Some(height),
+            ..self.clone()
+        })
+    }
+
+    pub(crate) fn nlocktime(&self, locktime: LockTime) -> Arc<Self> {
+        Arc::new(BumpFeeTxBuilder {
+            locktime: Some(locktime),
+            ..self.clone()
+        })
+    }
+
     pub(crate) fn finish(&self, wallet: &Arc<Wallet>) -> Result<Arc<Psbt>, CreateTxError> {
         let txid = Txid::from_str(self.txid.as_str()).map_err(|_| CreateTxError::UnknownUtxo {
             outpoint: self.txid.clone(),
@@ -277,6 +337,13 @@ impl BumpFeeTxBuilder {
         if let Some(sequence) = self.sequence {
             tx_builder.set_exact_sequence(Sequence(sequence));
         }
+        if let Some(height) = self.current_height {
+            tx_builder.current_height(height);
+        }
+        if let Some(locktime) = &self.locktime {
+            let bdk_locktime: BdkLockTime = locktime.try_into()?;
+            tx_builder.nlocktime(bdk_locktime);
+        }
 
         let psbt: BdkPsbt = tx_builder.finish()?;
 

bdk-ffi/src/types.rs

@@ -1,5 +1,5 @@
 use crate::bitcoin::{Address, Transaction, TxOut};
-use crate::error::RequestBuilderError;
+use crate::error::{CreateTxError, RequestBuilderError};
 
 use bitcoin_ffi::Amount;
 use bitcoin_ffi::OutPoint;
@@ -29,6 +29,7 @@ use bdk_wallet::LocalOutput as BdkLocalOutput;
 use bdk_wallet::Update as BdkUpdate;
 
 use std::collections::HashMap;
+use std::convert::TryFrom;
 use std::sync::{Arc, Mutex};
 
 #[derive(Debug)]
@@ -405,6 +406,19 @@ impl From<BdkLockTime> for LockTime {
     }
 }
 
+impl TryFrom<&LockTime> for BdkLockTime {
+    type Error = CreateTxError;
+
+    fn try_from(value: &LockTime) -> Result<Self, CreateTxError> {
+        match value {
+            LockTime::Blocks { height } => BdkLockTime::from_height(*height)
+                .map_err(|_| CreateTxError::LockTimeConversionError),
+            LockTime::Seconds { consensus_time } => BdkLockTime::from_time(*consensus_time)
+                .map_err(|_| CreateTxError::LockTimeConversionError),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum Satisfaction {
     Partial {