Wallet bid replacement and bidout selection clean up

Author: buffrr

node/src/bin/space-cli.rs

@@ -262,7 +262,7 @@ impl SpaceCli {
     async fn send_request(
         &self,
         req: Option<RpcWalletRequest>,
-        auction_outputs: Option<u8>,
+        bidouts: Option<u8>,
         fee_rate: Option<u64>,
     ) -> Result<(), ClientError> {
         let fee_rate = fee_rate.map(|fee| FeeRate::from_sat_per_vb(fee).unwrap());
@@ -271,7 +271,7 @@ impl SpaceCli {
             .wallet_send_request(
                 &self.wallet,
                 RpcWalletTxBuilder {
-                    auction_outputs,
+                    bidouts,
                     requests: match req {
                         None => vec![],
                         Some(req) => vec![req],
@@ -533,7 +533,7 @@ async fn handle_commands(
             println!("{}", serde_json::to_string_pretty(&spaces)?);
         }
         Commands::ListBidOuts => {
-            let spaces = cli.client.wallet_list_auction_outputs(&cli.wallet).await?;
+            let spaces = cli.client.wallet_list_bidouts(&cli.wallet).await?;
             println!("{}", serde_json::to_string_pretty(&spaces)?);
         }
         Commands::ListSpaces => {

node/src/rpc.rs

@@ -186,8 +186,8 @@ pub trait Rpc {
         wallet: &str,
     ) -> Result<Vec<WalletOutput>, ErrorObjectOwned>;
 
-    #[method(name = "walletlistauctionoutputs")]
-    async fn wallet_list_auction_outputs(
+    #[method(name = "walletlistbidouts")]
+    async fn wallet_list_bidouts(
         &self,
         wallet: &str,
     ) -> Result<Vec<DoubleUtxo>, ErrorObjectOwned>;
@@ -199,7 +199,7 @@ pub trait Rpc {
 #[derive(Clone, Serialize, Deserialize)]
 pub struct RpcWalletTxBuilder {
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub auction_outputs: Option<u8>,
+    pub bidouts: Option<u8>,
     pub requests: Vec<RpcWalletRequest>,
     pub fee_rate: Option<FeeRate>,
     pub dust: Option<Amount>,
@@ -764,13 +764,13 @@ impl RpcServer for RpcServerImpl {
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
-    async fn wallet_list_auction_outputs(
+    async fn wallet_list_bidouts(
         &self,
         wallet: &str,
     ) -> Result<Vec<DoubleUtxo>, ErrorObjectOwned> {
         self.wallet(&wallet)
             .await?
-            .send_list_auction_outputs()
+            .send_list_bidouts()
             .await
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }

node/src/wallets.rs

@@ -1,18 +1,9 @@
 use std::{collections::BTreeMap, str::FromStr, time::Duration};
-
 use anyhow::anyhow;
 use clap::ValueEnum;
 use futures::{stream::FuturesUnordered, StreamExt};
 use log::{info, warn};
-use protocol::{
-    bitcoin::Txid,
-    constants::ChainAnchor,
-    hasher::{KeyHasher, SpaceKey},
-    prepare::DataSource,
-    script::SpaceScript,
-    slabel::SLabel,
-    Space,
-};
+use protocol::{bitcoin::Txid, constants::ChainAnchor, hasher::{KeyHasher, SpaceKey}, prepare::DataSource, script::SpaceScript, slabel::SLabel, FullSpaceOut, Space};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tokio::{
@@ -34,6 +25,7 @@ use wallet::{
     DoubleUtxo, SpacesWallet, WalletInfo,
 };
 use wallet::bdk_wallet::wallet::tx_builder::TxOrdering;
+use wallet::builder::SelectionOutput;
 use crate::{
     config::ExtendedNetwork,
     node::BlockSource,
@@ -46,17 +38,18 @@ use crate::{
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TxResponse {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<BTreeMap<String, String>>,
     pub txid: Txid,
     pub tags: Vec<TransactionTag>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<BTreeMap<String, String>>,
+    pub raw: Option<String>,
 }
 
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct WalletResponse {
-    pub sent: Vec<TxResponse>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub raw: Option<Vec<String>>,
+    pub result: Vec<TxResponse>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -87,7 +80,7 @@ pub enum WalletCommand {
     ListSpaces {
         resp: crate::rpc::Responder<anyhow::Result<Vec<WalletOutput>>>,
     },
-    ListAuctionOutputs {
+    ListBidouts {
         resp: crate::rpc::Responder<anyhow::Result<Vec<DoubleUtxo>>>,
     },
     ListUnspent {
@@ -182,7 +175,11 @@ impl RpcWallet {
         txid: Txid,
         fee_rate: FeeRate,
     ) -> anyhow::Result<Vec<TxResponse>> {
-        let coin_selection = Self::get_spaces_coin_selection(wallet, state)?;
+        let coin_selection = Self::get_spaces_coin_selection(
+            wallet,
+            state,
+            false /* generally bdk won't use unconfirmed for replacements anyways */
+        )?;
         let mut builder = wallet.spaces
             .build_fee_bump(txid)?
             .coin_selection(coin_selection);
@@ -204,6 +201,7 @@ impl RpcWallet {
             txid: new_txid,
             tags: vec![TransactionTag::FeeBump],
             error: None,
+            raw: None,
         }])
     }
 
@@ -214,7 +212,8 @@ impl RpcWallet {
         output: OutPoint,
         fee_rate: FeeRate,
     ) -> anyhow::Result<TxResponse> {
-        let coin_selection = Self::get_spaces_coin_selection(wallet, state)?;
+        let coin_selection =
+            Self::get_spaces_coin_selection(wallet, state, true)?;
         let addre = wallet.spaces.next_unused_address(KeychainKind::External);
         let mut builder = wallet
             .spaces
@@ -239,6 +238,7 @@ impl RpcWallet {
             txid,
             tags: vec![TransactionTag::ForceSpendTestOnly],
             error: None,
+            raw: None,
         })
     }
 
@@ -299,8 +299,10 @@ impl RpcWallet {
                     }
                 }
             }
-            WalletCommand::ListAuctionOutputs { resp } => {
-                let result = wallet.list_auction_outputs();
+            WalletCommand::ListBidouts { resp } => {
+                let sel =
+                    Self::get_spaces_coin_selection(wallet, state, false)?;
+                let result = wallet.list_bidouts(&sel);
                 _ = resp.send(result);
             }
             WalletCommand::GetBalance { resp } => {
@@ -422,6 +424,7 @@ impl RpcWallet {
     fn get_spaces_coin_selection(
         wallet: &mut SpacesWallet,
         state: &mut LiveSnapshot,
+        confirmed_only: bool,
     ) -> anyhow::Result<SpacesAwareCoinSelection> {
         // Filters out all "space outs" from the selection.
         // Note: This exclusion only applies to confirmed space outs; unconfirmed ones are not excluded.
@@ -430,10 +433,14 @@ impl RpcWallet {
         let excluded = Self::list_unspent(wallet, state)?
             .into_iter()
             .filter(|out| out.is_spaceout)
-            .map(|out| out.output.outpoint)
+            .map(|out| SelectionOutput {
+                outpoint: out.output.outpoint,
+                is_space: out.space.is_some(),
+                is_spaceout: true,
+            })
             .collect::<Vec<_>>();
 
-        Ok(SpacesAwareCoinSelection::new(excluded))
+        Ok(SpacesAwareCoinSelection::new(excluded, confirmed_only))
     }
 
     fn list_unspent(
@@ -496,6 +503,17 @@ impl RpcWallet {
         )?))
     }
 
+    fn replaces_unconfirmed_bid(wallet: &SpacesWallet, bid_spaceout: &FullSpaceOut) -> bool {
+        let outpoint = bid_spaceout.outpoint();
+        wallet.spaces.transactions().filter(
+            |tx|
+                !tx.chain_position.is_confirmed()
+        ).any(
+            |tx|
+                tx.tx_node.input.iter().any(|input| input.previous_output == outpoint)
+        )
+    }
+
     fn batch_tx(
         network: ExtendedNetwork,
         source: &BitcoinBlockSource,
@@ -526,11 +544,13 @@ impl RpcWallet {
         let mut builder = wallet::builder::Builder::new();
         builder = builder.fee_rate(fee_rate);
 
-        if tx.auction_outputs.is_some() {
-            builder = builder.auction_outputs(tx.auction_outputs.unwrap());
+        if tx.bidouts.is_some() {
+            builder = builder.bidouts(tx.bidouts.unwrap());
         }
         builder = builder.force(tx.force);
 
+        let mut bid_replacement = false;
+
         for req in tx.requests {
             match req {
                 RpcWalletRequest::SendCoins(params) => {
@@ -603,7 +623,13 @@ impl RpcWallet {
                     if spaceout.is_none() {
                         return Err(anyhow!("bid '{}': space does not exist", params.name));
                     }
-                    builder = builder.add_bid(spaceout.unwrap(), Amount::from_sat(params.amount));
+
+                    let spaceout = spaceout.unwrap();
+                    if Self::replaces_unconfirmed_bid(wallet, &spaceout) {
+                        bid_replacement = true;
+                    }
+
+                    builder = builder.add_bid(spaceout, Amount::from_sat(params.amount));
                 }
                 RpcWalletRequest::Register(params) => {
                     let name = SLabel::from_str(&params.name)?;
@@ -686,13 +712,11 @@ impl RpcWallet {
         }
 
         let median_time = source.get_median_time()?;
-        let coin_selection = Self::get_spaces_coin_selection(wallet, store)?;
+        let coin_selection = Self::get_spaces_coin_selection(wallet, store, bid_replacement)?;
 
         let mut tx_iter = builder.build_iter(tx.dust, median_time, wallet, coin_selection)?;
 
         let mut result_set = Vec::new();
-        let mut raw_set = Vec::new();
-        let mut has_errors = false;
         while let Some(tx_result) = tx_iter.next() {
             let tagged = tx_result?;
 
@@ -701,27 +725,27 @@ impl RpcWallet {
                 txid: tagged.tx.compute_txid(),
                 tags: tagged.tags,
                 error: None,
+                raw: None,
             });
 
             let raw = bitcoin::consensus::encode::serialize_hex(&tagged.tx);
-            raw_set.push(raw);
             let result = source.rpc.broadcast_tx(&source.client, &tagged.tx);
             match result {
                 Ok(confirmation) => {
                     tx_iter.wallet.insert_tx(tagged.tx, confirmation)?;
                     tx_iter.wallet.commit()?;
                 }
                 Err(e) => {
-                    has_errors = true;
+                    result_set.last_mut().unwrap().raw = Some(raw);
+
                     let mut error_data = BTreeMap::new();
                     if let BitcoinRpcError::Rpc(rpc) = e {
                         if is_bid {
                             if rpc.message.contains("replacement-adds-unconfirmed") {
                                 error_data.insert(
                                     "hint".to_string(),
-                                    "If you have don't have confirmed auction outputs, you cannot \
-                                                  replace bids in the mempool."
-                                        .to_string(),
+                                    "Competing bid in mempool but wallet has no confirmed bid \
+                                    outputs (required to replace mempool bids)".to_string(),
                                 );
                             }
 
@@ -750,8 +774,7 @@ impl RpcWallet {
         }
 
         Ok(WalletResponse {
-            sent: result_set,
-            raw: if has_errors { Some(raw_set) } else { None },
+            result: result_set,
         })
     }
 
@@ -876,10 +899,10 @@ impl RpcWallet {
         resp_rx.await?
     }
 
-    pub async fn send_list_auction_outputs(&self) -> anyhow::Result<Vec<DoubleUtxo>> {
+    pub async fn send_list_bidouts(&self) -> anyhow::Result<Vec<DoubleUtxo>> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
-            .send(WalletCommand::ListAuctionOutputs { resp })
+            .send(WalletCommand::ListBidouts { resp })
             .await?;
         resp_rx.await?
     }