Merge branch 'main' into improvement/bitswap

Author: acul71

extra/multihash-spec

@@ -2,16 +2,14 @@ FROM python:3.13-slim
 
 WORKDIR /app
 
-# Install system dependencies (contributing.rst + transport Dockerfile)
-RUN apt-get update && apt-get install -y \
-    redis-tools \
+# Install only the toolchain needed to build/install py-libp2p.
+RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     cmake \
     pkg-config \
     libgmp-dev \
-    git \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/* /var/cache/apt/*.bin
 
 # Install uv (docs/contributing.rst Option 2: same as CI)
 RUN pip install --no-cache-dir uv

extra/py-multihash

@@ -22,6 +22,9 @@
 MAX_NOISE_MESSAGE_LEN = 2 ** (8 * SIZE_NOISE_MESSAGE_LEN) - 1
 SIZE_NOISE_MESSAGE_BODY_LEN = 2
 MAX_NOISE_MESSAGE_BODY_LEN = MAX_NOISE_MESSAGE_LEN - SIZE_NOISE_MESSAGE_BODY_LEN
+# Max plaintext per Noise message: 65535 - 16 bytes Poly1305 MAC overhead.
+# Matches go-libp2p's MaxPlaintextLength in p2p/security/noise/rw.go.
+MAX_PLAINTEXT_LENGTH = MAX_NOISE_MESSAGE_LEN - 16
 BYTE_ORDER = "big"
 
 # |                         Noise packet                            |
@@ -53,14 +56,26 @@ def __init__(self, conn: IRawConnection, noise_state: NoiseState) -> None:
         self.noise_state = noise_state
 
     async def write_msg(self, msg: bytes, prefix_encoded: bool = False) -> None:
-        logger.debug(f"Noise write_msg: encrypting {len(msg)} bytes")
-        data_encrypted = self.encrypt(msg)
-        if prefix_encoded:
-            # Manually add the prefix if needed
-            data_encrypted = self.prefix + data_encrypted
-        logger.debug(f"Noise write_msg: writing {len(data_encrypted)} encrypted bytes")
-        await self.read_writer.write_msg(data_encrypted)
-        logger.debug("Noise write_msg: write completed successfully")
+        # Chunk large messages to stay within the Noise 65535-byte transport
+        # message limit, matching go-libp2p's noise/rw.go Write() approach.
+        if len(msg) <= MAX_PLAINTEXT_LENGTH:
+            # Fast path: single message (covers handshake and small writes)
+            data_encrypted = self.encrypt(msg)
+            if prefix_encoded:
+                data_encrypted = self.prefix + data_encrypted
+            await self.read_writer.write_msg(data_encrypted)
+        else:
+            # Slow path: chunk into multiple Noise messages
+            total = len(msg)
+            written = 0
+            while written < total:
+                end = min(written + MAX_PLAINTEXT_LENGTH, total)
+                chunk = msg[written:end]
+                data_encrypted = self.encrypt(chunk)
+                if prefix_encoded and written == 0:
+                    data_encrypted = self.prefix + data_encrypted
+                await self.read_writer.write_msg(data_encrypted)
+                written = end
 
     async def read_msg(self, prefix_encoded: bool = False) -> bytes:
         logger.debug("Noise read_msg: reading encrypted message")

extra/pymultihash

@@ -94,24 +94,47 @@ async def read(self, n: int | None = None) -> bytes:
             return b""
 
         data_from_buffer = self._drain(n)
-        if len(data_from_buffer) > 0:
+        if n is None and len(data_from_buffer) > 0:
             return data_from_buffer
 
-        msg = await self.conn.read_msg()
+        if n is None:
+            msg = await self.conn.read_msg()
 
-        # If underlying connection returned empty bytes, treat as closed
-        # and raise to signal that reads after close are invalid.
-        if msg == b"":
-            raise Exception("Connection closed")
+            # If underlying connection returned empty bytes, treat as closed
+            # and raise to signal that reads after close are invalid.
+            if msg == b"":
+                raise Exception("Connection closed")
 
-        if n is None:
             return msg
 
-        if n < len(msg):
-            self._fill(msg)
-            return self._drain(n)
-        else:
-            return msg
+        if len(data_from_buffer) == n:
+            return data_from_buffer
+
+        result = bytearray(data_from_buffer)
+        while len(result) < n:
+            needed = n - len(result)
+            drained = self._drain(needed)
+            if drained:
+                result.extend(drained)
+                continue
+
+            msg = await self.conn.read_msg()
+
+            # If the connection closes after a partial read, return the bytes
+            # we already assembled. This preserves the stream-read behavior
+            # expected by higher layers.
+            if msg == b"":
+                if result:
+                    return bytes(result)
+                raise Exception("Connection closed")
+
+            if len(msg) <= needed:
+                result.extend(msg)
+            else:
+                result.extend(msg[:needed])
+                self._fill(msg[needed:])
+
+        return bytes(result)
 
     async def write(self, data: bytes) -> None:
         await self.conn.write_msg(data)