these were created while reviewing the bounty submissions.

Author: Your Name

test-libp2p-handshake.js

@@ -0,0 +1,83 @@
+const { FrameDecoder, FrameEncoder, encodeFrame } = require('./src/FrameCodec');
+const { once } = require('events');
+
+// Simulate libp2p multistream-select handshake protocol messages
+const MULTISTREAM_PROTOCOL = '/multistream/1.0.0\n';
+const NOISE_PROTOCOL = '/noise\n';
+const YAMUX_PROTOCOL = '/yamux/1.0.0\n';
+
+async function simulateLibp2pHandshake() {
+  console.log('=== Simulating libp2p multistream-select handshake ===\n');
+
+  const encoder = new FrameEncoder();
+  const decoder = new FrameDecoder();
+
+  const received = [];
+  decoder.on('data', (frame) => {
+    const msg = frame.toString();
+    console.log(`Received frame (${frame.length} bytes): ${JSON.stringify(msg)}`);
+    received.push(msg);
+  });
+
+  // Encode libp2p protocol negotiation messages
+  const messages = [
+    Buffer.from(MULTISTREAM_PROTOCOL),
+    Buffer.from(NOISE_PROTOCOL),
+    Buffer.from(YAMUX_PROTOCOL)
+  ];
+
+  console.log('Encoding messages as varint-prefixed frames:');
+  const frames = [];
+  for (const msg of messages) {
+    const frame = encodeFrame(msg);
+    console.log(`  "${msg.toString().trim()}" -> ${frame.length} bytes (varint: ${frame[0]}, payload: ${msg.length})`);
+    frames.push(frame);
+  }
+
+  const wire = Buffer.concat(frames);
+  console.log(`\nWire format: ${wire.length} bytes total\n`);
+
+  // Simulate TCP fragmentation - split at arbitrary boundaries
+  const fragments = [
+    wire.slice(0, 5),   // Split in middle of first message
+    wire.slice(5, 12),  // Split across varint boundary
+    wire.slice(12, 20), // Partial second message
+    wire.slice(20, 25), // Fragment
+    wire.slice(25)      // Rest
+  ];
+
+  console.log('Simulating TCP fragmentation:');
+  fragments.forEach((frag, i) => {
+    console.log(`  Fragment ${i}: ${frag.length} bytes`);
+  });
+  console.log();
+
+  // Feed fragmented chunks to decoder
+  console.log('Feeding fragments to decoder:\n');
+  for (const fragment of fragments) {
+    decoder.write(fragment);
+  }
+  decoder.end();
+
+  await once(decoder, 'end');
+
+  console.log(`\n=== Results ===`);
+  console.log(`Expected ${messages.length} messages, received ${received.length}`);
+  console.log(`Frame reconstruction: ${received.length === messages.length ? 'PASS ✓' : 'FAIL ✗'}`);
+
+  for (let i = 0; i < messages.length; i++) {
+    const expected = messages[i].toString();
+    const actual = received[i] || '';
+    const match = expected === actual;
+    console.log(`  Message ${i}: ${match ? 'PASS ✓' : 'FAIL ✗'} ${match ? '' : `(expected "${expected.trim()}", got "${actual.trim()}")`}`);
+  }
+
+  if (received.length === messages.length && received.every((msg, i) => msg === messages[i].toString())) {
+    console.log('\n🎉 libp2p multistream-select handshake would succeed!');
+    console.log('   No UnexpectedEOFError - frames reconstructed correctly across fragmentation');
+  } else {
+    console.log('\n❌ Handshake would fail - frame reconstruction error');
+  }
+}
+
+simulateLibp2pHandshake().catch(console.error);

test-tcp.js

@@ -0,0 +1,52 @@
+const { FrameDecoder, encodeFrame } = require('./src/FrameCodec');
+const { once } = require('events');
+const crypto = require('crypto');
+
+let _seed = 0xdeadbeef;
+function seededRandom() {
+  _seed = (_seed * 1664525 + 1013904223) >>> 0;
+  return _seed / 0x100000000;
+}
+
+function randomInt(min, max) {
+  return Math.floor(seededRandom() * (max - min + 1)) + min;
+}
+
+async function decodeWithFrameDecoder(chunks) {
+  const decoder = new FrameDecoder();
+  const frames = [];
+  decoder.on('data', (frame) => frames.push(Buffer.from(frame)));
+  const errorPromise = once(decoder, 'error').then(([err]) => { throw err; });
+  const endPromise = once(decoder, 'end').then(() => frames);
+  (async () => {
+    for (const chunk of chunks) {
+      if (!decoder.write(chunk)) await once(decoder, 'drain');
+    }
+    decoder.end();
+  })().catch((err) => decoder.emit('error', err));
+  return Promise.race([endPromise, errorPromise]);
+}
+
+(async () => {
+  const iterations = 10000;
+  const start = Date.now();
+  for (let i = 0; i < iterations; i++) {
+    const frameCount = randomInt(1, 12);
+    const frames = [];
+    for (let j = 0; j < frameCount; j++) frames.push(crypto.randomBytes(randomInt(0, 512)));
+    const wire = Buffer.concat(frames.map((frame) => encodeFrame(frame)));
+    const chunks = [];
+    let offset = 0;
+    while (offset < wire.length) {
+      const chunkLen = randomInt(1, Math.min(64, wire.length - offset));
+      chunks.push(wire.slice(offset, offset + chunkLen));
+      offset += chunkLen;
+    }
+    const decoded = await decodeWithFrameDecoder(chunks);
+    if (decoded.length !== frames.length) throw new Error(`Round ${i}: expected ${frames.length}, got ${decoded.length}`);
+    for (let k = 0; k < frames.length; k++) {
+      if (!decoded[k].equals(frames[k])) throw new Error(`Round ${i}: frame ${k} corruption`);
+    }
+  }
+  console.log(`${iterations} rounds: ${Date.now() - start}ms`);
+})();