feat(client): request the broadcast minimum FeeRate

example/signet.rs

@@ -70,6 +70,9 @@ async fn main() {
                         Event::Synced(update) => {
                             tracing::info!("Synced chain up to block {}",update.tip().height);
                             tracing::info!("Chain tip: {}",update.tip().hash);
+                            // Request information from the node
+                            let fee = sender.broadcast_min_feerate().await.unwrap();
+                            tracing::info!("Minimum transaction broadcast fee rate: {}", fee);
                             break;
                         },
                         Event::Block(indexed_block) => {

src/core/client.rs

@@ -1,9 +1,9 @@
-use bitcoin::block::Header;
 #[cfg(feature = "filter-control")]
 use bitcoin::BlockHash;
 #[cfg(not(feature = "filter-control"))]
 use bitcoin::ScriptBuf;
 use bitcoin::Transaction;
+use bitcoin::{block::Header, FeeRate};
 use std::{collections::BTreeMap, ops::Range, time::Duration};
 use tokio::sync::mpsc;
 pub use tokio::sync::mpsc::Receiver;
@@ -15,7 +15,7 @@ use crate::{Event, Log, TrustedPeer, TxBroadcast};
 #[cfg(feature = "filter-control")]
 use super::{error::FetchBlockError, messages::BlockRequest, BlockReceiver, IndexedBlock};
 use super::{
-    error::{ClientError, FetchHeaderError},
+    error::{ClientError, FetchFeeRateError, FetchHeaderError},
     messages::{BatchHeaderRequest, ClientMessage, HeaderRequest},
 };
 
@@ -133,6 +133,20 @@ impl EventSender {
             .map_err(|_| ClientError::SendError)
     }
 
+    /// A connection has a minimum transaction fee requirement to enter its mempool. For proper transaction propagation,
+    /// transactions should have a fee rate at least as high as the maximum fee filter received.
+    /// This method returns the maximum fee rate requirement of all connected peers.
+    ///
+    /// For more information, refer to BIP133
+    pub async fn broadcast_min_feerate(&self) -> Result<FeeRate, FetchFeeRateError> {
+        let (tx, rx) = tokio::sync::oneshot::channel::<FeeRate>();
+        self.ntx
+            .send(ClientMessage::GetBroadcastMinFeeRate(tx))
+            .await
+            .map_err(|_| FetchFeeRateError::SendError)?;
+        rx.await.map_err(|_| FetchFeeRateError::RecvError)
+    }
+
     /// Add more Bitcoin [`ScriptBuf`] to watch for. Does not rescan the filters.
     /// If the script was already present in the node's collection, no change will occur.
     ///

src/core/error.rs

@@ -202,3 +202,29 @@ impl core::fmt::Display for FetchBlockError {
 }
 
 impl_sourceless_error!(FetchBlockError);
+
+/// Errors that occur when fetching the minimum fee rate to broadcast a transaction.
+#[derive(Debug)]
+pub enum FetchFeeRateError {
+    /// The channel to the node was likely closed and dropped from memory.
+    /// This implies the node is not running.
+    SendError,
+    /// The channel to the client was likely closed by the node and dropped from memory.
+    RecvError,
+}
+
+impl core::fmt::Display for FetchFeeRateError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FetchFeeRateError::SendError => {
+                write!(f, "the receiver of this message was dropped from memory.")
+            }
+            FetchFeeRateError::RecvError => write!(
+                f,
+                "the channel to the client was likely closed by the node and dropped from memory."
+            ),
+        }
+    }
+}
+
+impl_sourceless_error!(FetchFeeRateError);

src/core/messages.rs

@@ -2,7 +2,7 @@ use std::{collections::BTreeMap, ops::Range, time::Duration};
 
 #[cfg(feature = "filter-control")]
 use bitcoin::BlockHash;
-use bitcoin::{block::Header, p2p::message_network::RejectReason, ScriptBuf, Txid};
+use bitcoin::{block::Header, p2p::message_network::RejectReason, FeeRate, ScriptBuf, Txid};
 
 #[cfg(feature = "filter-control")]
 use crate::IndexedFilter;
@@ -171,6 +171,8 @@ pub(crate) enum ClientMessage {
     GetHeader(HeaderRequest),
     /// Request a range of headers.
     GetHeaderBatch(BatchHeaderRequest),
+    /// Request the broadcast minimum fee rate.
+    GetBroadcastMinFeeRate(FeeRateSender),
 }
 
 type HeaderSender = tokio::sync::oneshot::Sender<Result<Header, FetchHeaderError>>;
@@ -204,6 +206,8 @@ impl BatchHeaderRequest {
 
 pub(crate) type BlockSender = tokio::sync::oneshot::Sender<Result<IndexedBlock, FetchBlockError>>;
 
+pub(crate) type FeeRateSender = tokio::sync::oneshot::Sender<FeeRate>;
+
 #[cfg(feature = "filter-control")]
 #[derive(Debug)]
 pub(crate) struct BlockRequest {

src/core/node.rs

@@ -336,6 +336,14 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
                                 if send_result.is_err() {
                                     self.dialog.send_warning(Warning::ChannelDropped).await
                                 };
+                            },
+                            ClientMessage::GetBroadcastMinFeeRate(request) => {
+                                let peer_map = self.peer_map.lock().await;
+                                let fee_rate = peer_map.broadcast_min();
+                                let send_result = request.send(fee_rate);
+                                if send_result.is_err() {
+                                    self.dialog.send_warning(Warning::ChannelDropped).await
+                                };
                             }
                         }
                     }

tests/core.rs

@@ -250,7 +250,7 @@ async fn test_mine_after_reorg() {
 }
 
 #[tokio::test]
-async fn test_long_chain() {
+async fn test_various_client_methods() {
     let rpc_result = start_bitcoind(false);
     // If we can't fetch the genesis block then bitcoind is not running. Just exit.
     if rpc_result.is_err() {
@@ -275,6 +275,7 @@ async fn test_long_chain() {
     } = client;
     sync_assert(&best, &mut channel, &mut log).await;
     let batch = sender.get_header_range(10_000..10_002).await.unwrap();
+    let _ = sender.broadcast_min_feerate().await.unwrap();
     assert!(batch.is_empty());
     sender.shutdown().await.unwrap();
     rpc.stop().unwrap();