don't send the full rejected block inside closing_connection_message

When a node disconnects a peer for offering a bad block, it sends the
exception in the goodbye message.  The generic capture embedded the entire
block; a block with transactions serializes deeper than the unpack-side
recursion limit (MAX_RECURSION_DEPTH=20), so no peer on the network could
actually decode these goodbyes -- during the 2026-07-09 incident one node
logged 6176 such failed unpacks, hiding the real disconnect reasons.
Capture only the block num and id (still useful to the disconnected peer).

Also make the receiver tolerant: if a closing_connection_message can't be
deserialized, log it and treat it as a close request without details
instead of tearing down the read loop with an assert -- the peer is
closing the connection either way.

Author: emfrias

libraries/net/node.cpp

@@ -2052,8 +2052,25 @@ namespace graphene { namespace net {
         on_item_ids_inventory_message(originating_peer, received_message.as<item_ids_inventory_message>());
         break;
       case core_message_type_enum::closing_connection_message_type:
-        on_closing_connection_message(originating_peer, received_message.as<closing_connection_message>());
-        break;
+        {
+          closing_connection_message closing_message_received;
+          try
+          {
+            closing_message_received = received_message.as<closing_connection_message>();
+          }
+          catch (const fc::exception& e)
+          {
+            // The peer is closing the connection regardless of whether we can read its reason for
+            // doing so, so don't treat an undecodable goodbye as a protocol error (e.g. older peers
+            // embed an exception whose serialization can nest deeper than our recursion limit).
+            wlog("Unable to decode closing_connection_message from peer ${peer}, treating it as a close request "
+                 "with no details: ${e}",
+                 ("peer", originating_peer->get_remote_endpoint())("e", e.to_detail_string()));
+            closing_message_received.reason_for_closing = "<unable to decode the closing_connection_message this peer sent us>";
+          }
+          on_closing_connection_message(originating_peer, closing_message_received);
+          break;
+        }
       case core_message_type_enum::block_message_type:
       case core_message_type_enum::compressed_block_message_type:
         fc::async( [=]() { process_block_message(originating_peer, received_message, message_hash); }, "process_block_msg");

libraries/plugins/chain/chain_plugin.cpp

@@ -1043,6 +1043,7 @@ bool chain_plugin_impl::push_block( const block_flow_control& block_ctrl, uint32
   const signed_block_header& new_block_header = new_block;
 
   uint32_t block_num = full_block->get_block_num();
+  const block_id_type block_id = full_block->get_block_id();
   if( !checkpoints.empty() && block_num <= checkpoints.rbegin()->first )
   {
     skip = database::skip_witness_signature
@@ -1083,7 +1084,10 @@ bool chain_plugin_impl::push_block( const block_flow_control& block_ctrl, uint32
         // we only need header (if anything at all) in most common case of block from unknown fork
         FC_RETHROW_EXCEPTION( er, warn, "", FC_FORMAT_ARG_PARAMS( (new_block_header) ) );
       }
-      FC_CAPTURE_AND_RETHROW( (new_block) )
+      // capture only the block's identity, not the full block: this exception is sent to the
+      // offending peer inside a closing_connection_message, and a full block nests deeper than
+      // the serializer's recursion limit, making the message undecodable by the receiver
+      FC_CAPTURE_AND_RETHROW( (block_num)(block_id) )
 
       db.check_free_memory( false, full_block->get_block_num() );
     });