@antseed/node 0.1.0

package/tests/default-router.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect } from 'vitest';
+import { DefaultRouter } from '../src/routing/default-router.js';
+import type { PeerInfo } from '../src/types/peer.js';
+import type { SerializedHttpRequest } from '../src/types/http.js';
+
+function makePeer(overrides?: Partial<PeerInfo>): PeerInfo {
+  return {
+    peerId: ('a'.repeat(64)) as any,
+    lastSeen: Date.now(),
+    providers: ['anthropic'],
+    reputationScore: 80,
+    defaultInputUsdPerMillion: 10,
+    ...overrides,
+  };
+}
+
+const dummyReq: SerializedHttpRequest = {
+  requestId: 'req-1',
+  method: 'POST',
+  path: '/v1/messages',
+  headers: {},
+  body: new Uint8Array(0),
+};
+
+describe('DefaultRouter', () => {
+  describe('selectPeer', () => {
+    it('should return null for empty peer list', () => {
+      const router = new DefaultRouter();
+      expect(router.selectPeer(dummyReq, [])).toBeNull();
+    });
+
+    it('should return null when no peer meets minimum reputation', () => {
+      const router = new DefaultRouter({ minReputation: 90 });
+      const peers = [
+        makePeer({ peerId: 'a'.repeat(64) as any, reputationScore: 50 }),
+        makePeer({ peerId: 'b'.repeat(64) as any, reputationScore: 80 }),
+      ];
+      expect(router.selectPeer(dummyReq, peers)).toBeNull();
+    });
+
+    it('should select cheapest peer', () => {
+      const router = new DefaultRouter();
+      const expensive = makePeer({ peerId: 'a'.repeat(64) as any, defaultInputUsdPerMillion: 1000 });
+      const cheap = makePeer({ peerId: 'b'.repeat(64) as any, defaultInputUsdPerMillion: 1 });
+      const selected = router.selectPeer(dummyReq, [expensive, cheap]);
+      expect(selected).not.toBeNull();
+      expect(selected!.peerId).toBe('b'.repeat(64));
+    });
+
+    it('should use default minReputation of 50', () => {
+      const router = new DefaultRouter();
+      const peer = makePeer({ reputationScore: 50 });
+      expect(router.selectPeer(dummyReq, [peer])).not.toBeNull();
+
+      const lowRep = makePeer({ reputationScore: 49 });
+      expect(router.selectPeer(dummyReq, [lowRep])).toBeNull();
+    });
+
+    it('should keep peers eligible when reputation is missing', () => {
+      const router = new DefaultRouter();
+      const peer = makePeer({ reputationScore: undefined });
+      expect(router.selectPeer(dummyReq, [peer])).not.toBeNull();
+    });
+
+    it('should enforce minReputation for explicit on-chain reputation', () => {
+      const router = new DefaultRouter({ minReputation: 50 });
+      const lowOnChain = makePeer({
+        peerId: 'a'.repeat(64) as any,
+        reputationScore: undefined,
+        trustScore: undefined,
+        onChainReputation: 25,
+      });
+      const highOnChain = makePeer({
+        peerId: 'b'.repeat(64) as any,
+        reputationScore: undefined,
+        trustScore: undefined,
+        onChainReputation: 90,
+      });
+
+      const selected = router.selectPeer(dummyReq, [lowOnChain, highOnChain]);
+      expect(selected?.peerId).toBe('b'.repeat(64));
+    });
+
+    it('should treat on-chain zero reputation with zero sessions as unrated', () => {
+      const router = new DefaultRouter({ minReputation: 50 });
+      const newSeller = makePeer({
+        peerId: 'a'.repeat(64) as any,
+        reputationScore: undefined,
+        trustScore: 0,
+        onChainReputation: 0,
+        onChainSessionCount: 0,
+        onChainDisputeCount: 0,
+      });
+
+      const selected = router.selectPeer(dummyReq, [newSeller]);
+      expect(selected?.peerId).toBe('a'.repeat(64));
+    });
+
+    it('should treat missing defaultInputUsdPerMillion as Infinity', () => {
+      const router = new DefaultRouter();
+      const withPrice = makePeer({ peerId: 'a'.repeat(64) as any, defaultInputUsdPerMillion: 500 });
+      const noPrice = makePeer({ peerId: 'b'.repeat(64) as any, defaultInputUsdPerMillion: undefined });
+      const selected = router.selectPeer(dummyReq, [withPrice, noPrice]);
+      expect(selected!.peerId).toBe('a'.repeat(64));
+    });
+  });
+
+  describe('onResult', () => {
+    it('should use latency for tiebreaking after recording results', () => {
+      const router = new DefaultRouter();
+      const peerA = makePeer({ peerId: 'a'.repeat(64) as any, defaultInputUsdPerMillion: 10 });
+      const peerB = makePeer({ peerId: 'b'.repeat(64) as any, defaultInputUsdPerMillion: 10 });
+
+      // Record peerA as slower, peerB as faster
+      router.onResult(peerA, { success: true, latencyMs: 500, tokens: 100 });
+      router.onResult(peerB, { success: true, latencyMs: 50, tokens: 100 });
+
+      const selected = router.selectPeer(dummyReq, [peerA, peerB]);
+      // Both have same price, so should pick lower latency
+      expect(selected!.peerId).toBe('b'.repeat(64));
+    });
+
+    it('should use exponential moving average for latency', () => {
+      const router = new DefaultRouter();
+      const peer = makePeer({ peerId: 'a'.repeat(64) as any });
+
+      router.onResult(peer, { success: true, latencyMs: 100, tokens: 100 });
+      router.onResult(peer, { success: true, latencyMs: 200, tokens: 100 });
+
+      // After first call: 100
+      // After second call: 100 * 0.7 + 200 * 0.3 = 70 + 60 = 130
+      // We can't directly check the latency map, but we can verify it influences selection
+      const peerFast = makePeer({ peerId: 'b'.repeat(64) as any, defaultInputUsdPerMillion: 10 });
+      router.onResult(peerFast, { success: true, latencyMs: 10, tokens: 100 });
+
+      const selected = router.selectPeer(dummyReq, [peer, peerFast]);
+      expect(selected!.peerId).toBe('b'.repeat(64));
+    });
+
+    it('should not update latency on failure', () => {
+      const router = new DefaultRouter();
+      const peer = makePeer({ peerId: 'a'.repeat(64) as any });
+      router.onResult(peer, { success: false, latencyMs: 999999, tokens: 0 });
+      // No latency recorded, so peer still has Infinity latency
+      // Just verify it doesn't crash
+    });
+  });
+});

package/tests/evm-keypair.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { isAddress, verifyMessage, getBytes, solidityPackedKeccak256 } from 'ethers';
+import { identityToEvmWallet, identityToEvmAddress } from '../src/payments/evm/keypair.js';
+import {
+  buildLockMessageHash,
+  buildSettlementMessageHash,
+  buildExtendLockMessageHash,
+  signMessageEcdsa,
+  buildReceiptMessage,
+  buildAckMessage,
+  signMessageEd25519,
+  verifyMessageEd25519,
+} from '../src/payments/evm/signatures.js';
+import { loadOrCreateIdentity } from '../src/p2p/identity.js';
+import { tmpdir } from 'node:os';
+import { mkdtemp } from 'node:fs/promises';
+import { join } from 'node:path';
+
+describe('EVM keypair from identity', () => {
+  it('produces a valid EVM wallet with a valid address', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+    const wallet = identityToEvmWallet(identity);
+
+    expect(wallet.address).toBeDefined();
+    expect(isAddress(wallet.address)).toBe(true);
+    expect(wallet.address.startsWith('0x')).toBe(true);
+  });
+
+  it('derived key is deterministic (same identity produces same wallet)', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+    const wallet1 = identityToEvmWallet(identity);
+    const wallet2 = identityToEvmWallet(identity);
+
+    expect(wallet1.address).toBe(wallet2.address);
+    expect(wallet1.privateKey).toBe(wallet2.privateKey);
+  });
+
+  it('different identities produce different wallets', async () => {
+    const dir1 = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const dir2 = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity1 = await loadOrCreateIdentity(dir1);
+    const identity2 = await loadOrCreateIdentity(dir2);
+    const wallet1 = identityToEvmWallet(identity1);
+    const wallet2 = identityToEvmWallet(identity2);
+
+    expect(wallet1.address).not.toBe(wallet2.address);
+  });
+
+  it('identityToEvmAddress returns the same address as the wallet', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+    const wallet = identityToEvmWallet(identity);
+    const address = identityToEvmAddress(identity);
+
+    expect(address).toBe(wallet.address);
+  });
+});
+
+describe('ECDSA signature helpers', () => {
+  it('sign and recover round-trip for lock message', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+    const wallet = identityToEvmWallet(identity);
+
+    const sessionId = '0x' + '01'.repeat(32);
+    const seller = '0x' + 'ab'.repeat(20);
+    const amount = 1_000_000n;
+
+    const messageHash = buildLockMessageHash(sessionId, seller, amount);
+    const sig = await signMessageEcdsa(wallet, messageHash);
+
+    const recoveredAddress = verifyMessage(getBytes(messageHash), sig);
+    expect(recoveredAddress.toLowerCase()).toBe(wallet.address.toLowerCase());
+  });
+
+  it('buildLockMessageHash produces correct keccak256 with domain byte 0x01', () => {
+    const sessionId = '0x' + '01'.repeat(32);
+    const seller = '0x' + 'ab'.repeat(20);
+    const amount = 500_000n;
+
+    const hash = buildLockMessageHash(sessionId, seller, amount);
+    const expected = solidityPackedKeccak256(
+      ['bytes1', 'bytes32', 'address', 'uint256'],
+      ['0x01', sessionId, seller, amount],
+    );
+    expect(hash).toBe(expected);
+  });
+
+  it('buildSettlementMessageHash produces correct hash', () => {
+    const sessionId = '0x' + '02'.repeat(32);
+    const runningTotal = 400_000n;
+    const score = 85;
+
+    const hash = buildSettlementMessageHash(sessionId, runningTotal, score);
+    const expected = solidityPackedKeccak256(
+      ['bytes32', 'uint256', 'uint8'],
+      [sessionId, runningTotal, score],
+    );
+    expect(hash).toBe(expected);
+  });
+
+  it('buildExtendLockMessageHash produces correct hash with domain byte 0x02', () => {
+    const sessionId = '0x' + '03'.repeat(32);
+    const seller = '0x' + 'cd'.repeat(20);
+    const additionalAmount = 200_000n;
+
+    const hash = buildExtendLockMessageHash(sessionId, seller, additionalAmount);
+    const expected = solidityPackedKeccak256(
+      ['bytes1', 'bytes32', 'address', 'uint256'],
+      ['0x02', sessionId, seller, additionalAmount],
+    );
+    expect(hash).toBe(expected);
+  });
+});
+
+describe('Ed25519 off-chain signatures', () => {
+  it('buildReceiptMessage produces 76-byte message', () => {
+    const sessionId = new Uint8Array(32).fill(1);
+    const runningTotal = 1_000_000n;
+    const requestCount = 5;
+    const responseHash = new Uint8Array(32).fill(0xab);
+
+    const msg = buildReceiptMessage(sessionId, runningTotal, requestCount, responseHash);
+    expect(msg.length).toBe(76);
+    expect(msg.slice(0, 32)).toEqual(sessionId);
+    expect(msg.slice(44, 76)).toEqual(responseHash);
+  });
+
+  it('buildAckMessage produces 44-byte message', () => {
+    const sessionId = new Uint8Array(32).fill(2);
+    const runningTotal = 500_000n;
+    const requestCount = 3;
+
+    const msg = buildAckMessage(sessionId, runningTotal, requestCount);
+    expect(msg.length).toBe(44);
+    expect(msg.slice(0, 32)).toEqual(sessionId);
+  });
+
+  it('Ed25519 sign and verify round-trip', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+
+    const message = new Uint8Array([1, 2, 3, 4, 5]);
+    const sig = await signMessageEd25519(identity, message);
+    const valid = await verifyMessageEd25519(identity.publicKey, sig, message);
+    expect(valid).toBe(true);
+  });
+
+  it('Ed25519 verify rejects tampered message', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity = await loadOrCreateIdentity(dir);
+
+    const message = new Uint8Array([1, 2, 3, 4, 5]);
+    const sig = await signMessageEd25519(identity, message);
+    const tampered = new Uint8Array([1, 2, 3, 4, 6]);
+    const valid = await verifyMessageEd25519(identity.publicKey, sig, tampered);
+    expect(valid).toBe(false);
+  });
+
+  it('Ed25519 verify rejects wrong public key', async () => {
+    const dir1 = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const dir2 = await mkdtemp(join(tmpdir(), 'lch-test-'));
+    const identity1 = await loadOrCreateIdentity(dir1);
+    const identity2 = await loadOrCreateIdentity(dir2);
+
+    const message = new Uint8Array([10, 20, 30]);
+    const sig = await signMessageEd25519(identity1, message);
+    const valid = await verifyMessageEd25519(identity2.publicKey, sig, message);
+    expect(valid).toBe(false);
+  });
+});

package/tests/identity.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import {
+  loadOrCreateIdentity,
+  signData,
+  verifySignature,
+  hexToBytes,
+  bytesToHex,
+  signUtf8Ed25519,
+  verifyUtf8Ed25519,
+} from '../src/p2p/identity.js';
+
+function tmpDir(): string {
+  return path.join(os.tmpdir(), `antseed-test-${randomBytes(8).toString('hex')}`);
+}
+
+const dirsToClean: string[] = [];
+
+afterEach(async () => {
+  for (const dir of dirsToClean) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+  dirsToClean.length = 0;
+});
+
+describe('hexToBytes / bytesToHex', () => {
+  it('should round-trip bytes', () => {
+    const original = new Uint8Array([0, 1, 127, 255, 16]);
+    const hex = bytesToHex(original);
+    const back = hexToBytes(hex);
+    expect(back).toEqual(original);
+  });
+
+  it('should produce lowercase hex', () => {
+    const hex = bytesToHex(new Uint8Array([0xab, 0xcd]));
+    expect(hex).toBe('abcd');
+  });
+
+  it('should throw for odd-length hex string', () => {
+    expect(() => hexToBytes('abc')).toThrow('even length');
+  });
+});
+
+describe('loadOrCreateIdentity', () => {
+  it('should create a new identity when config dir does not exist', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const identity = await loadOrCreateIdentity(dir);
+
+    expect(identity.peerId).toMatch(/^[0-9a-f]{64}$/);
+    expect(identity.privateKey).toBeInstanceOf(Uint8Array);
+    expect(identity.publicKey).toBeInstanceOf(Uint8Array);
+    expect(identity.publicKey.length).toBe(32);
+  });
+
+  it('should persist and reload the same identity', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const first = await loadOrCreateIdentity(dir);
+    const second = await loadOrCreateIdentity(dir);
+
+    expect(second.peerId).toBe(first.peerId);
+    expect(bytesToHex(second.privateKey)).toBe(bytesToHex(first.privateKey));
+    expect(bytesToHex(second.publicKey)).toBe(bytesToHex(first.publicKey));
+  });
+});
+
+describe('signData / verifySignature', () => {
+  it('should sign and verify data', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const identity = await loadOrCreateIdentity(dir);
+    const data = new TextEncoder().encode('hello world');
+    const signature = await signData(identity.privateKey, data);
+
+    expect(signature).toBeInstanceOf(Uint8Array);
+    expect(signature.length).toBe(64);
+
+    const valid = await verifySignature(identity.publicKey, signature, data);
+    expect(valid).toBe(true);
+  });
+
+  it('should fail verification with wrong data', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const identity = await loadOrCreateIdentity(dir);
+    const data = new TextEncoder().encode('hello');
+    const signature = await signData(identity.privateKey, data);
+
+    const wrongData = new TextEncoder().encode('world');
+    const valid = await verifySignature(identity.publicKey, signature, wrongData);
+    expect(valid).toBe(false);
+  });
+});
+
+describe('signUtf8Ed25519 / verifyUtf8Ed25519', () => {
+  it('should sign and verify a UTF-8 message', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const identity = await loadOrCreateIdentity(dir);
+    const message = 'receipt|data|12345';
+    const sig = signUtf8Ed25519(identity.privateKey, message);
+
+    expect(sig).toMatch(/^[0-9a-f]+$/);
+    expect(sig.length).toBe(128); // 64 bytes = 128 hex chars
+
+    const valid = verifyUtf8Ed25519(identity.peerId, message, sig);
+    expect(valid).toBe(true);
+  });
+
+  it('should fail verification with wrong message', async () => {
+    const dir = tmpDir();
+    dirsToClean.push(dir);
+
+    const identity = await loadOrCreateIdentity(dir);
+    const sig = signUtf8Ed25519(identity.privateKey, 'correct');
+    const valid = verifyUtf8Ed25519(identity.peerId, 'wrong', sig);
+    expect(valid).toBe(false);
+  });
+
+  it('should fail verification with invalid public key', () => {
+    const valid = verifyUtf8Ed25519('invalidhex', 'msg', 'ab'.repeat(64));
+    expect(valid).toBe(false);
+  });
+});

package/tests/message-protocol.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest';
+import {
+  encodeFrame,
+  decodeFrame,
+  FrameDecoder,
+  MessageMux,
+} from '../src/p2p/message-protocol.js';
+import {
+  MessageType,
+  FRAME_HEADER_SIZE,
+  MAX_PAYLOAD_SIZE,
+  type FramedMessage,
+} from '../src/types/protocol.js';
+
+describe('encodeFrame / decodeFrame', () => {
+  it('should round-trip a basic message', () => {
+    const msg: FramedMessage = {
+      type: MessageType.HttpRequest,
+      messageId: 42,
+      payload: new TextEncoder().encode('hello'),
+    };
+
+    const encoded = encodeFrame(msg);
+    const result = decodeFrame(encoded);
+
+    expect(result).not.toBeNull();
+    expect(result!.message.type).toBe(MessageType.HttpRequest);
+    expect(result!.message.messageId).toBe(42);
+    expect(new TextDecoder().decode(result!.message.payload)).toBe('hello');
+    expect(result!.bytesConsumed).toBe(FRAME_HEADER_SIZE + 5);
+  });
+
+  it('should round-trip a message with empty payload', () => {
+    const msg: FramedMessage = {
+      type: MessageType.Ping,
+      messageId: 0,
+      payload: new Uint8Array(0),
+    };
+
+    const encoded = encodeFrame(msg);
+    const result = decodeFrame(encoded);
+
+    expect(result).not.toBeNull();
+    expect(result!.message.type).toBe(MessageType.Ping);
+    expect(result!.message.payload.length).toBe(0);
+    expect(result!.bytesConsumed).toBe(FRAME_HEADER_SIZE);
+  });
+
+  it('should throw for payload exceeding MAX_PAYLOAD_SIZE', () => {
+    const msg: FramedMessage = {
+      type: MessageType.HttpRequest,
+      messageId: 1,
+      payload: new Uint8Array(MAX_PAYLOAD_SIZE + 1),
+    };
+    expect(() => encodeFrame(msg)).toThrow('Payload too large');
+  });
+
+  it('should return null for incomplete header', () => {
+    const data = new Uint8Array(5); // less than FRAME_HEADER_SIZE (9)
+    expect(decodeFrame(data)).toBeNull();
+  });
+
+  it('should return null for incomplete payload', () => {
+    // Create a valid header saying payload is 100 bytes, but only give 10
+    const msg: FramedMessage = {
+      type: MessageType.HttpRequest,
+      messageId: 1,
+      payload: new Uint8Array(100),
+    };
+    const encoded = encodeFrame(msg);
+    // Truncate to header + 10 bytes
+    const truncated = encoded.slice(0, FRAME_HEADER_SIZE + 10);
+    expect(decodeFrame(truncated)).toBeNull();
+  });
+
+  it('should throw for decoded payload length exceeding MAX_PAYLOAD_SIZE', () => {
+    const buf = new Uint8Array(FRAME_HEADER_SIZE);
+    const view = new DataView(buf.buffer);
+    view.setUint8(0, MessageType.HttpRequest);
+    view.setUint32(1, 1);
+    view.setUint32(5, MAX_PAYLOAD_SIZE + 1);
+    expect(() => decodeFrame(buf)).toThrow('exceeds maximum');
+  });
+
+  it('should handle all message types', () => {
+    for (const type of Object.values(MessageType).filter((v) => typeof v === 'number') as MessageType[]) {
+      const msg: FramedMessage = { type, messageId: 1, payload: new Uint8Array(0) };
+      const encoded = encodeFrame(msg);
+      const decoded = decodeFrame(encoded);
+      expect(decoded).not.toBeNull();
+      expect(decoded!.message.type).toBe(type);
+    }
+  });
+});
+
+describe('FrameDecoder', () => {
+  it('should decode a single frame fed all at once', () => {
+    const decoder = new FrameDecoder();
+    const msg: FramedMessage = {
+      type: MessageType.Pong,
+      messageId: 7,
+      payload: new TextEncoder().encode('pong'),
+    };
+    const encoded = encodeFrame(msg);
+    const frames = decoder.feed(encoded);
+
+    expect(frames).toHaveLength(1);
+    expect(frames[0]!.messageId).toBe(7);
+    expect(decoder.bufferedBytes).toBe(0);
+  });
+
+  it('should decode multiple frames fed at once', () => {
+    const decoder = new FrameDecoder();
+    const msg1 = encodeFrame({ type: MessageType.Ping, messageId: 1, payload: new Uint8Array(0) });
+    const msg2 = encodeFrame({ type: MessageType.Pong, messageId: 2, payload: new Uint8Array(0) });
+
+    const combined = new Uint8Array(msg1.length + msg2.length);
+    combined.set(msg1, 0);
+    combined.set(msg2, msg1.length);
+
+    const frames = decoder.feed(combined);
+    expect(frames).toHaveLength(2);
+    expect(frames[0]!.messageId).toBe(1);
+    expect(frames[1]!.messageId).toBe(2);
+  });
+
+  it('should handle partial frames across multiple feeds', () => {
+    const decoder = new FrameDecoder();
+    const msg = encodeFrame({
+      type: MessageType.HttpRequest,
+      messageId: 99,
+      payload: new TextEncoder().encode('test payload'),
+    });
+
+    // Feed first half
+    const half = Math.floor(msg.length / 2);
+    const frames1 = decoder.feed(msg.slice(0, half));
+    expect(frames1).toHaveLength(0);
+    expect(decoder.bufferedBytes).toBe(half);
+
+    // Feed second half
+    const frames2 = decoder.feed(msg.slice(half));
+    expect(frames2).toHaveLength(1);
+    expect(frames2[0]!.messageId).toBe(99);
+    expect(decoder.bufferedBytes).toBe(0);
+  });
+
+  it('should reset internal buffer', () => {
+    const decoder = new FrameDecoder();
+    decoder.feed(new Uint8Array(5)); // partial data
+    expect(decoder.bufferedBytes).toBe(5);
+    decoder.reset();
+    expect(decoder.bufferedBytes).toBe(0);
+  });
+});
+
+describe('MessageMux', () => {
+  it('should dispatch to registered handler', async () => {
+    const mux = new MessageMux();
+    const received: FramedMessage[] = [];
+    mux.on(MessageType.Ping, (msg) => {
+      received.push(msg);
+    });
+
+    await mux.dispatch({ type: MessageType.Ping, messageId: 1, payload: new Uint8Array(0) });
+    expect(received).toHaveLength(1);
+  });
+
+  it('should call default handler for unregistered types', async () => {
+    const mux = new MessageMux();
+    const defaultReceived: FramedMessage[] = [];
+    mux.setDefaultHandler((msg) => {
+      defaultReceived.push(msg);
+    });
+
+    await mux.dispatch({ type: MessageType.Error, messageId: 1, payload: new Uint8Array(0) });
+    expect(defaultReceived).toHaveLength(1);
+  });
+
+  it('should not call default handler when type-specific handler exists', async () => {
+    const mux = new MessageMux();
+    let defaultCalled = false;
+    mux.setDefaultHandler(() => {
+      defaultCalled = true;
+    });
+    mux.on(MessageType.Ping, () => {});
+
+    await mux.dispatch({ type: MessageType.Ping, messageId: 1, payload: new Uint8Array(0) });
+    expect(defaultCalled).toBe(false);
+  });
+
+  it('should support multiple handlers per type', async () => {
+    const mux = new MessageMux();
+    let count = 0;
+    mux.on(MessageType.Ping, () => { count++; });
+    mux.on(MessageType.Ping, () => { count++; });
+
+    await mux.dispatch({ type: MessageType.Ping, messageId: 1, payload: new Uint8Array(0) });
+    expect(count).toBe(2);
+  });
+
+  it('should remove handler with off()', async () => {
+    const mux = new MessageMux();
+    let count = 0;
+    const handler = () => { count++; };
+    mux.on(MessageType.Ping, handler);
+    mux.off(MessageType.Ping, handler);
+
+    await mux.dispatch({ type: MessageType.Ping, messageId: 1, payload: new Uint8Array(0) });
+    expect(count).toBe(0);
+  });
+});