Add fee-rate support (RGB PSBT) (#366)

* feat: add fee-rate in rgb psbt

* feat: add minimum sats to fund vault

* Bump bitmask-core to 0.6.3-rc.21.

---------

Co-authored-by: Hunter Trujillo <[email protected]>

Author: crisdut

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bitmask-core"
-version = "0.6.3-rc.20"
+version = "0.6.3-rc.21"
 authors = [
     "Jose Diego Robles <[email protected]>",
     "Hunter Trujillo <[email protected]>",

Cargo.toml

@@ -39,6 +39,9 @@ use crate::{
     trace,
 };
 
+// Minimum amount of satoshis to funding vault
+const MIN_FUNDS_SATS: u64 = 10000;
+
 impl SerdeEncryptSharedKey for DecryptedWalletData {
     type S = BincodeSerializer<Self>;
 }
@@ -57,12 +60,17 @@ pub enum BitcoinError {
     /// Wrong Encrypted Descriptor Version
     #[error("Wrong Version: Encrypted descriptor is the wrong version. The version byte was: {0}")]
     WrongEncryptedDescriptorVersion(u8),
+    #[error("Wrong Descriptor: Wallet supports only taproot descriptor")]
+    WrongDescriptor,
     /// Upgrade unnecessary
     #[error("Descriptor does not need to be upgraded")]
     UpgradeUnnecessary,
     /// Wrong network
     #[error("Address provided is on the wrong network!")]
     WrongNetwork,
+    /// Wrong Encrypted Descriptor Format
+    #[error("Insufficient satoshis to create funding wallet. Minimum: {0} sats")]
+    InsufficientFundSats(u64),
     /// Drain wallet unable to finalize PSBT
     #[error("Drain wallet was unable to finalize PSBT")]
     DrainWalletUnfinalizedPsbt,
@@ -296,13 +304,9 @@ pub async fn get_new_address(
     info!("get_new_address");
 
     let wallet = get_wallet(descriptor, change_descriptor).await?;
-    let address = wallet
-        .lock()
-        .await
-        .get_address(AddressIndex::New)?
-        .to_string();
+    let address = wallet.lock().await.get_address(AddressIndex::New)?;
     info!(format!("address: {address}"));
-    Ok(address)
+    Ok(address.to_string())
 }
 
 pub async fn validate_address(address: &Address) -> Result<(), BitcoinError> {
@@ -360,6 +364,14 @@ pub async fn fund_vault(
     uda_address_2: &str,
     fee_rate: Option<f32>,
 ) -> Result<FundVaultDetails, BitcoinError> {
+    let wallet = get_wallet(btc_descriptor_xprv, Some(btc_change_descriptor_xprv)).await?;
+    let fee_rate = fee_rate.map(FeeRate::from_sat_per_vb);
+
+    let balance = wallet.lock().await.get_balance()?;
+    if balance.confirmed < MIN_FUNDS_SATS {
+        return Err(BitcoinError::InsufficientFundSats(MIN_FUNDS_SATS));
+    };
+
     let assets_address_1 = Address::from_str(assets_address_1)?;
     let assets_address_2 = Address::from_str(assets_address_2)?;
     let uda_address_1 = Address::from_str(uda_address_1)?;
@@ -384,9 +396,6 @@ pub async fn fund_vault(
         amount: rng.gen_range(600..1500),
     };
 
-    let wallet = get_wallet(btc_descriptor_xprv, Some(btc_change_descriptor_xprv)).await?;
-    let fee_rate = fee_rate.map(FeeRate::from_sat_per_vb);
-
     let asset_tx_details = create_transaction(
         vec![
             asset_invoice_1,

src/bitcoin.rs

@@ -50,6 +50,7 @@ pub async fn create_transaction(
         for invoice in invoices {
             builder.add_recipient(invoice.address.script_pubkey(), invoice.amount);
         }
+
         builder.ordering(TxOrdering::Untouched); // TODO: Remove after implementing wallet persistence
         builder.enable_rbf().fee_rate(fee_rate.unwrap_or_default());
         builder.finish()?

src/bitcoin/payment.rs

@@ -1,5 +1,5 @@
 use bdk::{blockchain::Blockchain, psbt::PsbtUtils, SignOptions, TransactionDetails};
-use bitcoin::{consensus::serialize, util::psbt::PartiallySignedTransaction};
+use bitcoin::{consensus::serialize, hashes::hex::ToHex, util::psbt::PartiallySignedTransaction};
 use thiserror::Error;
 
 use crate::{
@@ -35,7 +35,7 @@ pub async fn sign_psbt(
         debug!("Signed PSBT:", base64::encode(&serialize(&psbt)));
         let fee_amount = psbt.fee_amount().expect("fee amount on PSBT is known");
         let tx = psbt.extract_tx();
-        debug!("tx:", base64::encode(&serialize(&tx.clone())));
+        debug!("tx:", &serialize(&tx.clone()).to_hex());
         let blockchain = get_blockchain().await;
         blockchain.broadcast(&tx).await?;
 
@@ -105,7 +105,7 @@ pub async fn sign_psbt_with_multiple_wallets(
         debug!("Signed PSBT:", base64::encode(&serialize(&psbt)));
         let fee_amount = psbt.fee_amount().expect("fee amount on PSBT is known");
         let tx = psbt.extract_tx();
-        debug!("tx:", base64::encode(&serialize(&tx.clone())));
+        debug!("tx:", &serialize(&tx.clone()).to_hex());
         let blockchain = get_blockchain().await;
         blockchain.broadcast(&tx).await?;
 

src/bitcoin/psbt.rs

@@ -88,7 +88,7 @@ use self::{
         prefetch_resolver_user_utxo_status, prefetch_resolver_utxos, prefetch_resolver_waddress,
         prefetch_resolver_wutxo,
     },
-    psbt::{fee_estimate, save_commit, CreatePsbtError},
+    psbt::{save_commit, CreatePsbtError, EstimateFeeError},
     structs::{RgbAccount, RgbTransfer, RgbTransfers},
     transfer::{extract_transfer, AcceptTransferError, NewInvoiceError, NewPaymentError},
     wallet::{
@@ -464,10 +464,22 @@ pub enum TransferError {
     NoContract,
     /// Iface is required in this operation. Please, use the correct iface contract.
     NoIface,
+    /// FeeRate is supported in this operation. Please, use the absolute fee value.
+    NoFeeRate,
+    /// Insufficient funds (expected: {input} sats / current: {output} sats)
+    Inflation {
+        /// Amount spent: input amounts
+        input: u64,
+
+        /// Amount sent: sum of output value + transaction fee
+        output: u64,
+    },
     /// Auto merge fail in this opration
     WrongAutoMerge(String),
     /// Occurs an error in create step. {0}
     Create(CreatePsbtError),
+    /// Occurs an error in estimate fee step. {0}
+    Estimate(EstimateFeeError),
     /// Occurs an error in commitment step. {0}
     Commitment(DbcPsbtError),
     /// Occurs an error in payment step. {0}
@@ -515,11 +527,11 @@ async fn internal_create_psbt(
 
     let PsbtRequest {
         asset_inputs,
-        asset_descriptor_change,
         asset_terminal_change,
         bitcoin_inputs,
         bitcoin_changes,
         fee,
+        ..
     } = request;
 
     let mut all_inputs = asset_inputs.clone();
@@ -531,15 +543,7 @@ async fn internal_create_psbt(
     // Retrieve transaction fee
     let fee = match fee {
         PsbtFeeRequest::Value(fee) => fee,
-        PsbtFeeRequest::FeeRate(fee_rate) => fee_estimate(
-            asset_inputs,
-            asset_descriptor_change,
-            asset_terminal_change.clone(),
-            bitcoin_inputs,
-            bitcoin_changes.clone(),
-            fee_rate,
-            resolver,
-        ),
+        PsbtFeeRequest::FeeRate(_) => return Err(TransferError::NoFeeRate),
     };
 
     let wallet = rgb_account.wallets.get("default");
@@ -600,19 +604,18 @@ pub async fn full_transfer_asset(
         _ => return Err(TransferError::NoWatcher),
     };
 
-    let (asset_inputs, bitcoin_inputs, bitcoin_changes) =
+    let (asset_inputs, bitcoin_inputs, bitcoin_changes, fee_value) =
         prebuild_transfer_asset(request.clone(), &mut stock, &mut rgb_wallet, &mut resolver)
             .await?;
 
     let FullRgbTransferRequest {
         rgb_invoice,
         change_terminal,
-        fee,
         ..
     } = request;
 
     let psbt_req = PsbtRequest {
-        fee,
+        fee: PsbtFeeRequest::Value(fee_value),
         asset_inputs,
         bitcoin_inputs,
         bitcoin_changes,
@@ -1387,7 +1390,7 @@ pub async fn watcher_address(
     name: &str,
     address: &str,
 ) -> Result<WatcherUtxoResponse, WatcherError> {
-    let rgb_account = retrieve_account(sk).await.map_err(WatcherError::IO)?;
+    let mut rgb_account = retrieve_account(sk).await.map_err(WatcherError::IO)?;
 
     let mut resp = WatcherUtxoResponse::default();
     if let Some(wallet) = rgb_account.wallets.get(name) {
@@ -1406,6 +1409,14 @@ pub async fn watcher_address(
             .into_iter()
             .map(|utxo| utxo.outpoint.to_string())
             .collect();
+
+        rgb_account
+            .wallets
+            .insert(RGB_DEFAULT_NAME.to_string(), wallet);
+
+        store_account(sk, rgb_account)
+            .await
+            .map_err(WatcherError::IO)?;
     };
 
     Ok(resp)
@@ -1560,6 +1571,7 @@ pub async fn watcher_unspent_utxos(
         ..Default::default()
     };
 
+    sync_wallet(iface_index, &mut wallet, &mut resolver);
     prefetch_resolver_utxos(
         iface_index,
         &mut wallet,
@@ -1568,7 +1580,6 @@ pub async fn watcher_unspent_utxos(
     )
     .await;
     prefetch_resolver_user_utxo_status(iface_index, &mut wallet, &mut resolver, true).await;
-    sync_wallet(iface_index, &mut wallet, &mut resolver);
 
     let utxos: HashSet<UtxoResponse> = next_utxos(iface_index, wallet.clone(), &mut resolver)
         .map_err(|op| WatcherError::Validation(op.to_string()))?