Add a way to fetch transactions in P2P without specifying a peer

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 - [2321](https://github.com/FuelLabs/fuel-core/pull/2321): New metrics for the txpool: "The size of transactions in the txpool" (`txpool_tx_size`), "The time spent by a transaction in the txpool in seconds" (`txpool_tx_time_in_txpool_seconds`), The number of transactions in the txpool (`txpool_number_of_transactions`), "The number of transactions pending verification before entering the txpool" (`txpool_number_of_transactions_pending_verification`), "The number of executable transactions in the txpool" (`txpool_number_of_executable_transactions`), "The time it took to select transactions for inclusion in a block in nanoseconds" (`txpool_select_transaction_time_nanoseconds`), The time it took to insert a transaction in the txpool in milliseconds (`txpool_insert_transaction_time_milliseconds`).
+- [2376](https://github.com/FuelLabs/fuel-core/pull/2376): Add a way to fetch transactions in P2P without specifying a peer.
 
 ## [Version 0.40.0]
 

crates/services/p2p/src/service.rs

@@ -115,6 +115,10 @@ pub enum TaskRequest {
         channel: OnResponse<Option<Vec<SealedBlockHeader>>>,
     },
     GetTransactions {
+        block_height_range: Range<u32>,
+        channel: OnResponse<Option<Vec<Transactions>>>,
+    },
+    GetTransactionsFromPeer {
         block_height_range: Range<u32>,
         from_peer: PeerId,
         channel: OnResponse<Option<Vec<Transactions>>>,
@@ -165,6 +169,9 @@ impl Debug for TaskRequest {
             TaskRequest::GetTransactions { .. } => {
                 write!(f, "TaskRequest::GetTransactions")
             }
+            TaskRequest::GetTransactionsFromPeer { .. } => {
+                write!(f, "TaskRequest::GetTransactionsFromPeer")
+            }
             TaskRequest::TxPoolGetAllTxIds { .. } => {
                 write!(f, "TaskRequest::TxPoolGetAllTxIds")
             }
@@ -856,7 +863,16 @@ where
                             tracing::warn!("No peers found for block at height {:?}", height);
                         }
                     }
-                    Some(TaskRequest::GetTransactions { block_height_range, from_peer, channel }) => {
+                    Some(TaskRequest::GetTransactions {block_height_range, channel }) => {
+                        let channel = ResponseSender::Transactions(channel);
+                        let request_msg = RequestMessage::Transactions(block_height_range.clone());
+                        let height = BlockHeight::from(block_height_range.end.saturating_sub(1));
+                        let peer = self.p2p_service.get_peer_id_with_height(&height);
+                        if self.p2p_service.send_request_msg(peer, request_msg, channel).is_err() {
+                            return Err(anyhow!("No peers found for block at height {:?}", height));
+                        }
+                    }
+                    Some(TaskRequest::GetTransactionsFromPeer { block_height_range, from_peer, channel }) => {
                         let channel = ResponseSender::Transactions(channel);
                         let request_msg = RequestMessage::Transactions(block_height_range);
                         self.p2p_service.send_request_msg(Some(from_peer), request_msg, channel).expect("We always a peer here, so send has a target");
@@ -1020,6 +1036,31 @@ impl SharedState {
         Ok((peer_id.to_bytes(), data))
     }
 
+    pub async fn get_transactions(
+        &self,
+        range: Range<u32>,
+    ) -> anyhow::Result<(Vec<u8>, Option<Vec<Transactions>>)> {
+        let (sender, receiver) = oneshot::channel();
+
+        if range.is_empty() {
+            return Err(anyhow!(
+                "Cannot retrieve transactions for an empty range of block heights"
+            ));
+        }
+
+        self.request_sender
+            .send(TaskRequest::GetTransactions {
+                block_height_range: range,
+                channel: sender,
+            })
+            .await?;
+
+        let (peer_id, response) = receiver.await.map_err(|e| anyhow!("{e}"))?;
+
+        let data = response.map_err(|e| anyhow!("Invalid response from peer {e:?}"))?;
+        Ok((peer_id.to_bytes(), data))
+    }
+
     pub async fn get_transactions_from_peer(
         &self,
         peer_id: FuelPeerId,
@@ -1028,7 +1069,7 @@ impl SharedState {
         let (sender, receiver) = oneshot::channel();
         let from_peer = PeerId::from_bytes(peer_id.as_ref()).expect("Valid PeerId");
 
-        let request = TaskRequest::GetTransactions {
+        let request = TaskRequest::GetTransactionsFromPeer {
             block_height_range: range,
             from_peer,
             channel: sender,