[Optimize] Add guards for processing unconfirmed solutions

node/rest/src/lib.rs

@@ -224,3 +224,13 @@ async fn log_middleware(
 
     Ok(next.run(request).await)
 }
+
+/// Formats an ID into a truncated identifier (for logging purposes).
+pub fn fmt_id(id: impl ToString) -> String {
+    let id = id.to_string();
+    let mut formatted_id = id.chars().take(16).collect::<String>();
+    if id.chars().count() > 16 {
+        formatted_id.push_str("..");
+    }
+    formatted_id
+}

node/rest/src/routes.rs

@@ -313,6 +313,11 @@ impl<N: Network, C: ConsensusStorage<N>, R: Routing<N>> Rest<N, C, R> {
         State(rest): State<Self>,
         Json(tx): Json<Transaction<N>>,
     ) -> Result<ErasedJson, RestError> {
+        // Do not process the transaction if the node is syncing.
+        if !rest.routing.is_block_synced() {
+            return Err(RestError(format!("Unable to broadcast transaction '{}' (node is syncing)", fmt_id(tx.id()))));
+        }
+
         // If the consensus module is enabled, add the unconfirmed transaction to the memory pool.
         if let Some(consensus) = rest.consensus {
             // Add the unconfirmed transaction to the memory pool.
@@ -337,10 +342,38 @@ impl<N: Network, C: ConsensusStorage<N>, R: Routing<N>> Rest<N, C, R> {
         State(rest): State<Self>,
         Json(solution): Json<Solution<N>>,
     ) -> Result<ErasedJson, RestError> {
+        // Do not process the solution if the node is syncing.
+        if !rest.routing.is_block_synced() {
+            return Err(RestError(format!(
+                "Unable to broadcast solution '{}' (node is syncing)",
+                fmt_id(solution.id())
+            )));
+        }
+
         // If the consensus module is enabled, add the unconfirmed solution to the memory pool.
-        if let Some(consensus) = rest.consensus {
+        // Otherwise, verify it prior to broadcasting.
+        match rest.consensus {
             // Add the unconfirmed solution to the memory pool.
-            consensus.add_unconfirmed_solution(solution).await?;
+            Some(consensus) => consensus.add_unconfirmed_solution(solution).await?,
+            // Verify the solution.
+            None => {
+                // Compute the current epoch hash.
+                let epoch_hash = rest.ledger.latest_epoch_hash()?;
+                // Retrieve the current proof target.
+                let proof_target = rest.ledger.latest_proof_target();
+                // Ensure that the solution is valid for the given epoch.
+                let puzzle = rest.ledger.puzzle().clone();
+                // Verify the solution in a blocking task.
+                match tokio::task::spawn_blocking(move || puzzle.check_solution(&solution, epoch_hash, proof_target))
+                    .await
+                {
+                    Ok(Ok(())) => {}
+                    Ok(Err(err)) => {
+                        return Err(RestError(format!("Invalid solution '{}' - {err}", fmt_id(solution.id()))));
+                    }
+                    Err(err) => return Err(RestError(format!("Invalid solution '{}' - {err}", fmt_id(solution.id())))),
+                }
+            }
         }
 
         let solution_id = solution.id();

node/router/src/inbound.rs

@@ -207,15 +207,20 @@ pub trait Inbound<N: Network>: Reading + Outbound<N> {
                 }
             }
             Message::UnconfirmedSolution(message) => {
-                // Clone the serialized message.
-                let serialized = message.clone();
+                // Do not process unconfirmed solutions if the node is syncing.
+                if !self.is_block_synced() {
+                    trace!("Skipped processing unconfirmed solution '{}' (node is syncing)", message.solution_id);
+                    return Ok(());
+                }
                 // Update the timestamp for the unconfirmed solution.
                 let seen_before = self.router().cache.insert_inbound_solution(peer_ip, message.solution_id).is_some();
                 // Determine whether to propagate the solution.
                 if seen_before {
                     trace!("Skipping 'UnconfirmedSolution' from '{peer_ip}'");
                     return Ok(());
                 }
+                // Clone the serialized message.
+                let serialized = message.clone();
                 // Perform the deferred non-blocking deserialization of the solution.
                 let solution = match message.solution.deserialize().await {
                     Ok(solution) => solution,
@@ -232,8 +237,11 @@ pub trait Inbound<N: Network>: Reading + Outbound<N> {
                 }
             }
             Message::UnconfirmedTransaction(message) => {
-                // Clone the serialized message.
-                let serialized = message.clone();
+                // Do not process unconfirmed transactions if the node is syncing.
+                if !self.is_block_synced() {
+                    trace!("Skipped processing unconfirmed transaction '{}' (node is syncing)", message.transaction_id);
+                    return Ok(());
+                }
                 // Update the timestamp for the unconfirmed transaction.
                 let seen_before =
                     self.router().cache.insert_inbound_transaction(peer_ip, message.transaction_id).is_some();
@@ -242,6 +250,8 @@ pub trait Inbound<N: Network>: Reading + Outbound<N> {
                     trace!("Skipping 'UnconfirmedTransaction' from '{peer_ip}'");
                     return Ok(());
                 }
+                // Clone the serialized message.
+                let serialized = message.clone();
                 // Perform the deferred non-blocking deserialization of the transaction.
                 let transaction = match message.transaction.deserialize().await {
                     Ok(transaction) => transaction,

node/router/src/outbound.rs

@@ -28,6 +28,9 @@ pub trait Outbound<N: Network>: Writing<Message = Message<N>> {
     /// Returns a reference to the router.
     fn router(&self) -> &Router<N>;
 
+    /// Returns `true` if the node is synced up to the latest block (within the given tolerance).
+    fn is_block_synced(&self) -> bool;
+
     /// Sends a "Ping" message to the given peer.
     fn send_ping(&self, peer_ip: SocketAddr, block_locators: Option<BlockLocators<N>>) {
         self.send(peer_ip, Message::Ping(Ping::new(self.router().node_type(), block_locators)));

node/router/tests/common/router.rs

@@ -149,6 +149,11 @@ impl<N: Network> Outbound<N> for TestRouter<N> {
     fn router(&self) -> &Router<N> {
         &self.0
     }
+
+    /// Returns `true` if the node is synced up to the latest block (within the given tolerance).
+    fn is_block_synced(&self) -> bool {
+        true
+    }
 }
 
 #[async_trait]

node/src/client/router.rs

@@ -163,6 +163,11 @@ impl<N: Network, C: ConsensusStorage<N>> Outbound<N> for Client<N, C> {
     fn router(&self) -> &Router<N> {
         &self.router
     }
+
+    /// Returns `true` if the node is synced up to the latest block (within the given tolerance).
+    fn is_block_synced(&self) -> bool {
+        self.sync.is_block_synced()
+    }
 }
 
 #[async_trait]

node/src/prover/router.rs

@@ -135,6 +135,11 @@ impl<N: Network, C: ConsensusStorage<N>> Outbound<N> for Prover<N, C> {
     fn router(&self) -> &Router<N> {
         &self.router
     }
+
+    /// Returns `true` if the node is synced up to the latest block (within the given tolerance).
+    fn is_block_synced(&self) -> bool {
+        true
+    }
 }
 
 #[async_trait]

node/src/validator/router.rs

@@ -137,6 +137,11 @@ impl<N: Network, C: ConsensusStorage<N>> Outbound<N> for Validator<N, C> {
     fn router(&self) -> &Router<N> {
         &self.router
     }
+
+    /// Returns `true` if the node is synced up to the latest block (within the given tolerance).
+    fn is_block_synced(&self) -> bool {
+        self.sync.is_block_synced()
+    }
 }
 
 #[async_trait]