fix: release P2P channel receive buffer after large message EOF (#2815)

## Summary
- Replace `ch.recving = ch.recving[:0]` with `ch.recving = make([]byte,
0, ch.desc.RecvBufferCapacity)` in `Channel.recvPacketMsg` so that large
backing arrays are released to GC after message completion instead of
being retained for the connection lifetime.
- Add unit tests verifying buffer capacity resets to baseline after
single-packet and multi-packet large messages.

## Rationale
A remote peer can pin large heap allocations (~128 MiB per connection on
the BLOCKSYNC channel) by sending one large message and keeping the
connection open. With 40 default inbound peers, this enables ~5 GiB of
pinned heap leading to OOM. The fix ensures the receive buffer shrinks
back to its baseline capacity (default 4 KiB) after each message
completes.

## Test plan
- [x] `TestRecvPacketMsgReleasesBufferAfterLargeMessage` — verifies
buffer cap returns to baseline after a single large EOF message
- [x] `TestRecvPacketMsgMultiPacketMessage` — verifies buffer cap
returns to baseline after multi-chunk reassembly
- [x] All existing `p2p/conn` tests pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
(cherry picked from commit dc43229)

Author: 2 people

p2p/conn/connection.go

@@ -899,11 +899,11 @@ func (ch *Channel) recvPacketMsg(packet tmp2p.PacketMsg) ([]byte, error) {
 	ch.recving = append(ch.recving, packet.Data...)
 	if packet.EOF {
 		msgBytes := ch.recving
-		// clear the slice without re-allocating.
-		// http://stackoverflow.com/questions/16971741/how-do-you-clear-a-slice-in-go
-		//   suggests this could be a memory leak, but we might as well keep the memory for the channel until it closes,
-		//	at which point the recving slice stops being used and should be garbage collected
-		ch.recving = ch.recving[:0] // make([]byte, 0, ch.desc.RecvBufferCapacity)
+		// Reset the receive buffer to the baseline capacity so that large
+		// message allocations are not retained for the lifetime of the
+		// connection. Without this, a peer can pin memory by sending a
+		// single large message and keeping the connection open.
+		ch.recving = make([]byte, 0, ch.desc.RecvBufferCapacity)
 		return msgBytes, nil
 	}
 	return nil, nil

p2p/conn/connection_test.go

@@ -618,6 +618,80 @@ func TestMConnectionChannelOverflow(t *testing.T) {
 
 }
 
+func TestRecvPacketMsgReleasesBufferAfterLargeMessage(t *testing.T) {
+	const (
+		recvBufCap = 4 * 1024        // 4 KiB baseline
+		msgSize    = 8 * 1024 * 1024 // 8 MiB message
+	)
+
+	ch := &Channel{
+		desc: ChannelDescriptor{
+			ID:                  0x01,
+			Priority:            1,
+			RecvBufferCapacity:  recvBufCap,
+			RecvMessageCapacity: msgSize + 1024,
+		},
+		recving: make([]byte, 0, recvBufCap),
+	}
+
+	require.Equal(t, recvBufCap, cap(ch.recving))
+
+	data := make([]byte, msgSize)
+	msgBytes, err := ch.recvPacketMsg(tmp2p.PacketMsg{Data: data, EOF: true})
+	require.NoError(t, err)
+	require.Len(t, msgBytes, msgSize)
+
+	// After EOF, the receive buffer must be reset to the baseline capacity
+	// rather than retaining the large backing array.
+	require.Equal(t, 0, len(ch.recving))
+	require.Equal(t, recvBufCap, cap(ch.recving),
+		"receive buffer capacity should shrink back to RecvBufferCapacity after EOF")
+}
+
+func TestRecvPacketMsgMultiPacketMessage(t *testing.T) {
+	const (
+		recvBufCap = 4 * 1024 // 4 KiB baseline
+		chunkSize  = 1024     // 1 KiB per packet
+		numChunks  = 100      // 100 KiB total message
+	)
+
+	ch := &Channel{
+		desc: ChannelDescriptor{
+			ID:                  0x01,
+			Priority:            1,
+			RecvBufferCapacity:  recvBufCap,
+			RecvMessageCapacity: chunkSize*numChunks + 1024,
+		},
+		recving: make([]byte, 0, recvBufCap),
+	}
+
+	// Send non-EOF chunks that accumulate in the buffer.
+	for i := 0; i < numChunks-1; i++ {
+		msgBytes, err := ch.recvPacketMsg(tmp2p.PacketMsg{
+			Data: make([]byte, chunkSize),
+			EOF:  false,
+		})
+		require.NoError(t, err)
+		require.Nil(t, msgBytes, "non-EOF packet should not return message bytes")
+	}
+
+	// Buffer should have grown to hold the accumulated data.
+	require.Equal(t, chunkSize*(numChunks-1), len(ch.recving))
+
+	// Final EOF chunk completes the message.
+	msgBytes, err := ch.recvPacketMsg(tmp2p.PacketMsg{
+		Data: make([]byte, chunkSize),
+		EOF:  true,
+	})
+	require.NoError(t, err)
+	require.Len(t, msgBytes, chunkSize*numChunks)
+
+	// Buffer must be reset to baseline after EOF.
+	require.Equal(t, 0, len(ch.recving))
+	require.Equal(t, recvBufCap, cap(ch.recving),
+		"receive buffer capacity should shrink back to RecvBufferCapacity after EOF")
+}
+
 type stopper interface {
 	Stop() error
 }