@peerbit/libp2p-test-utils 2.2.0-bbf27fa → 2.2.0-cb91e7b

package/dist/src/inmemory-libp2p.js

@@ -0,0 +1,918 @@
+import { UnsupportedProtocolError, } from "@libp2p/interface";
+import { multiaddr } from "@multiformats/multiaddr";
+import { getPublicKeyFromPeerId } from "@peerbit/crypto";
+import { pushable } from "it-pushable";
+import sodium from "libsodium-wrappers";
+const parseTcpPort = (addr) => {
+    const str = addr.toString();
+    const m = str.match(/\/tcp\/(\d+)/);
+    if (!m)
+        return undefined;
+    return Number(m[1]);
+};
+const isPeerId = (value) => {
+    return (typeof value === "object" &&
+        value != null &&
+        typeof value.toString === "function" &&
+        value.type != null &&
+        value.publicKey != null);
+};
+const decodeUVarint = (buf) => {
+    let x = 0;
+    let s = 0;
+    for (let i = 0; i < buf.length; i++) {
+        const b = buf[i];
+        if (b < 0x80) {
+            if (i > 9 || (i === 9 && b > 1))
+                throw new Error("varint overflow");
+            return { value: x | (b << s), bytes: i + 1 };
+        }
+        x |= (b & 0x7f) << s;
+        s += 7;
+    }
+    throw new Error("unexpected eof decoding varint");
+};
+const readU32LE = (buf, offset) => (buf[offset + 0] |
+    (buf[offset + 1] << 8) |
+    (buf[offset + 2] << 16) |
+    (buf[offset + 3] << 24)) >>>
+    0;
+const shouldDropByMessageIdPrefix = (encodedFrame, base) => {
+    // MessageHeader.id starts at base+2 (after DataMessage + MessageHeader variants).
+    const idOffset = base + 2;
+    const b0 = encodedFrame[idOffset + 0];
+    const b1 = encodedFrame[idOffset + 1];
+    const b2 = encodedFrame[idOffset + 2];
+    const b3 = encodedFrame[idOffset + 3];
+    // Allow loss injection without breaking stream-level control plane:
+    // - "FOUT": FanoutTree data plane
+    return (b0 === 0x46 && b1 === 0x4f && b2 === 0x55 && b3 === 0x54 // "FOUT"
+    );
+};
+const mulberry32 = (seed) => {
+    let t = seed >>> 0;
+    return () => {
+        t += 0x6d2b79f5;
+        let x = t;
+        x = Math.imul(x ^ (x >>> 15), x | 1);
+        x ^= x + Math.imul(x ^ (x >>> 7), x | 61);
+        return ((x ^ (x >>> 14)) >>> 0) / 4294967296;
+    };
+};
+export class InMemoryRegistrar {
+    handlers = new Map();
+    topologies = new Map();
+    topologySeq = 0;
+    async handle(protocol, handler, _opts) {
+        this.handlers.set(protocol, handler);
+    }
+    async unhandle(protocol) {
+        this.handlers.delete(protocol);
+    }
+    async register(protocol, topology) {
+        const id = `topology-${++this.topologySeq}`;
+        this.topologies.set(id, { protocol, topology });
+        return id;
+    }
+    async unregister(id) {
+        this.topologies.delete(id);
+    }
+    getHandler(protocol) {
+        return this.handlers.get(protocol);
+    }
+    getTopologies() {
+        return this.topologies.values();
+    }
+}
+class InMemoryStream extends EventTarget {
+    protocol;
+    direction;
+    id;
+    inbound;
+    readable;
+    rxDelayMs;
+    closed = false;
+    bufferedBytes = 0;
+    highWaterMark;
+    lowWaterMark;
+    backpressured = false;
+    pendingLengthPrefix;
+    peer;
+    recordSend;
+    shouldDrop;
+    recordDrop;
+    constructor(opts) {
+        super();
+        this.id = opts.id;
+        this.protocol = opts.protocol;
+        this.direction = opts.direction;
+        this.recordSend = opts.recordSend;
+        this.shouldDrop = opts.shouldDrop;
+        this.recordDrop = opts.recordDrop;
+        this.rxDelayMs = opts.rxDelayMs ?? 0;
+        this.highWaterMark = opts.highWaterMarkBytes ?? 256 * 1024;
+        this.lowWaterMark = Math.floor(this.highWaterMark / 2);
+        this.inbound = pushable({ objectMode: true });
+        const self = this;
+        this.readable = (async function* () {
+            for await (const chunk of self.inbound) {
+                if (self.rxDelayMs > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, self.rxDelayMs));
+                }
+                self.bufferedBytes = Math.max(0, self.bufferedBytes - chunk.byteLength);
+                if (self.backpressured && self.bufferedBytes <= self.lowWaterMark) {
+                    self.backpressured = false;
+                    self.peer?.dispatchEvent(new Event("drain"));
+                }
+                yield chunk;
+            }
+        })();
+    }
+    [Symbol.asyncIterator]() {
+        return this.readable[Symbol.asyncIterator]();
+    }
+    send(data) {
+        if (this.closed) {
+            throw new Error("Cannot send on closed stream");
+        }
+        // `it-length-prefixed` may yield the length prefix and the message body as
+        // separate chunks. Dropping only one of them would corrupt framing and can
+        // deadlock decoders. Buffer the prefix chunk so loss injection operates on
+        // whole messages.
+        if (this.pendingLengthPrefix) {
+            const prefix = this.pendingLengthPrefix;
+            this.pendingLengthPrefix = undefined;
+            const frame = new Uint8Array(prefix.byteLength + data.byteLength);
+            frame.set(prefix, 0);
+            frame.set(data, prefix.byteLength);
+            this.recordSend?.(frame);
+            if (this.shouldDrop?.(frame)) {
+                this.recordDrop?.(frame);
+                return true;
+            }
+            const remote = this.peer;
+            if (!remote)
+                throw new Error("Missing remote stream endpoint");
+            remote.bufferedBytes += frame.byteLength;
+            remote.inbound.push(frame);
+            if (remote.bufferedBytes > remote.highWaterMark) {
+                remote.backpressured = true;
+                return false;
+            }
+            return true;
+        }
+        // Prefix-only chunk? Buffer it and wait for the body chunk.
+        try {
+            const { bytes } = decodeUVarint(data);
+            if (bytes === data.byteLength && data.byteLength <= 10) {
+                this.pendingLengthPrefix = data;
+                return true;
+            }
+        }
+        catch {
+            // not a varint prefix
+        }
+        // Full frame already (prefix+body).
+        this.recordSend?.(data);
+        if (this.shouldDrop?.(data)) {
+            this.recordDrop?.(data);
+            return true;
+        }
+        const remote = this.peer;
+        if (!remote) {
+            throw new Error("Missing remote stream endpoint");
+        }
+        remote.bufferedBytes += data.byteLength;
+        remote.inbound.push(data);
+        if (remote.bufferedBytes > remote.highWaterMark) {
+            remote.backpressured = true;
+            return false;
+        }
+        return true;
+    }
+    abort(_err) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            this.inbound.end();
+        }
+        catch { }
+        this.dispatchEvent(new Event("close"));
+    }
+    close(_opts) {
+        this.abort();
+        return Promise.resolve();
+    }
+}
+class InMemoryConnection {
+    id;
+    remotePeer;
+    remoteAddr;
+    streams = [];
+    status = "open";
+    limits = undefined;
+    timeline = { open: Date.now(), close: undefined };
+    getLocalRegistrar;
+    getRemoteRegistrar;
+    getRemoteConnection;
+    recordSend;
+    shouldDrop;
+    recordDrop;
+    recordStreamOpen;
+    streamHighWaterMarkBytes;
+    streamRxDelayMs;
+    streamSeq = 0;
+    pair;
+    constructor(opts) {
+        this.id = opts.id;
+        this.remotePeer = opts.remotePeer;
+        this.remoteAddr = opts.remoteAddr;
+        this.getLocalRegistrar = opts.getLocalRegistrar;
+        this.getRemoteRegistrar = opts.getRemoteRegistrar;
+        this.getRemoteConnection = opts.getRemoteConnection;
+        this.recordSend = opts.recordSend;
+        this.shouldDrop = opts.shouldDrop;
+        this.recordDrop = opts.recordDrop;
+        this.recordStreamOpen = opts.recordStreamOpen;
+        this.streamHighWaterMarkBytes = opts.streamHighWaterMarkBytes;
+        this.streamRxDelayMs = opts.streamRxDelayMs;
+    }
+    _setPair(pair) {
+        this.pair = pair;
+    }
+    async newStream(protocols, opts) {
+        if (this.status !== "open") {
+            throw new Error("Connection is not open");
+        }
+        if (opts?.signal?.aborted) {
+            throw opts.signal.reason ?? new Error("Stream open aborted");
+        }
+        const list = Array.isArray(protocols) ? protocols : [protocols];
+        const protocol = list[0];
+        if (!protocol) {
+            throw new Error("Missing protocol");
+        }
+        const handler = this.getRemoteRegistrar().getHandler(protocol);
+        if (!handler) {
+            const err = new UnsupportedProtocolError(`No handler registered for protocol ${protocol}`);
+            err.code = "ERR_UNSUPPORTED_PROTOCOL";
+            throw err;
+        }
+        this.recordStreamOpen();
+        const remoteConn = this.getRemoteConnection();
+        const localStreamNo = ++this.streamSeq;
+        const remoteStreamNo = ++remoteConn.streamSeq;
+        const localStreamId = `${this.id}:out:${localStreamNo}`;
+        const remoteStreamId = `${remoteConn.id}:in:${remoteStreamNo}`;
+        const outbound = new InMemoryStream({
+            id: localStreamId,
+            protocol,
+            direction: "outbound",
+            recordSend: this.recordSend,
+            shouldDrop: this.shouldDrop,
+            recordDrop: this.recordDrop,
+            highWaterMarkBytes: this.streamHighWaterMarkBytes,
+        });
+        const inbound = new InMemoryStream({
+            id: remoteStreamId,
+            protocol,
+            direction: "inbound",
+            highWaterMarkBytes: this.streamHighWaterMarkBytes,
+            rxDelayMs: this.streamRxDelayMs,
+        });
+        outbound.peer = inbound;
+        inbound.peer = outbound;
+        this.streams.push(outbound);
+        remoteConn.streams.push(inbound);
+        const invokeHandler = () => handler(inbound, remoteConn).catch(() => {
+            // ignore handler errors in the transport shim
+        });
+        if (opts?.negotiateFully === false) {
+            // Fire handler async to better match real libp2p behavior.
+            queueMicrotask(() => {
+                invokeHandler();
+            });
+        }
+        else {
+            // When negotiateFully=true, invoke handler synchronously so the remote has
+            // a chance to attach inbound handlers before the caller starts sending.
+            invokeHandler();
+        }
+        return outbound;
+    }
+    async _closeLocal() {
+        if (this.status !== "open")
+            return;
+        this.status = "closed";
+        this.timeline.close = Date.now();
+        for (const s of this.streams) {
+            try {
+                s.close?.();
+            }
+            catch { }
+        }
+    }
+    async close(_opts) {
+        if (this.pair) {
+            await this.pair.close(this);
+            return;
+        }
+        await this._closeLocal();
+    }
+}
+class InMemoryConnectionPair {
+    opts;
+    closePromise;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async close(_initiator) {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = (async () => {
+            const { aConn, bConn, aOwner, bOwner, aManager, bManager, network } = this.opts;
+            await Promise.all([aConn._closeLocal(), bConn._closeLocal()]);
+            aManager._removeConnectionInstance(bOwner.peerId.toString(), aConn);
+            bManager._removeConnectionInstance(aOwner.peerId.toString(), bConn);
+            network.metrics.connectionsClosed += 1;
+            network.notifyDisconnect(aOwner, bOwner.peerId, [aConn]);
+            network.notifyDisconnect(bOwner, aOwner.peerId, [bConn]);
+        })();
+        return this.closePromise;
+    }
+}
+export class InMemoryAddressManager {
+    addr;
+    constructor(addr) {
+        this.addr = addr;
+    }
+    getAddresses() {
+        return [this.addr];
+    }
+}
+export class InMemoryPeerStore {
+    getAddressesForPeerId;
+    constructor(getAddressesForPeerId) {
+        this.getAddressesForPeerId = getAddressesForPeerId;
+    }
+    async get(peerId) {
+        const addrs = this.getAddressesForPeerId(peerId) ?? [];
+        return { addresses: addrs.map((multiaddr) => ({ multiaddr })) };
+    }
+    async delete(_peerId) {
+        // noop
+    }
+}
+export class InMemoryConnectionManager {
+    network;
+    owner;
+    connectionsByRemote = new Map();
+    dialQueue = [];
+    connSeqBase;
+    constructor(network, owner, opts) {
+        this.network = network;
+        this.owner = owner;
+        this.connSeqBase = opts?.connSeqBase ?? owner.peerId.toString();
+    }
+    getConnections(peerId) {
+        if (!peerId) {
+            return [...this.connectionsByRemote.values()].flat();
+        }
+        return (this.connectionsByRemote.get(peerId.toString()) ?? []);
+    }
+    getConnectionsMap() {
+        return {
+            get: (peer) => this.getConnections(peer),
+        };
+    }
+    getDialQueue() {
+        return this.dialQueue;
+    }
+    async isDialable(addr) {
+        if (this.network.isPeerOffline(this.owner.peerId))
+            return false;
+        const list = Array.isArray(addr) ? addr : [addr];
+        for (const a of list) {
+            const port = parseTcpPort(a);
+            if (port == null)
+                continue;
+            const remote = this.network.getPeerByPort(port);
+            if (!remote)
+                continue;
+            if (this.network.isPeerOffline(remote.peerId))
+                continue;
+            if (remote.peerId.toString() === this.owner.peerId.toString())
+                continue;
+            return true;
+        }
+        return false;
+    }
+    async openConnection(peer) {
+        if (this.network.isPeerOffline(this.owner.peerId)) {
+            throw new Error("Peer is offline");
+        }
+        const remote = (() => {
+            if (isPeerId(peer)) {
+                return this.network.getPeerById(peer.toString());
+            }
+            const list = Array.isArray(peer) ? peer : [peer];
+            for (const addr of list) {
+                const port = parseTcpPort(addr);
+                if (port == null)
+                    continue;
+                const found = this.network.getPeerByPort(port);
+                if (!found)
+                    continue;
+                if (found.peerId.toString() === this.owner.peerId.toString())
+                    continue;
+                return found;
+            }
+            return undefined;
+        })();
+        if (!remote) {
+            throw new Error("No dialable address");
+        }
+        if (this.network.isPeerOffline(remote.peerId)) {
+            throw new Error("Peer is offline");
+        }
+        const remoteKey = remote.peerId.toString();
+        const existing = this.connectionsByRemote.get(remoteKey)?.find((c) => c.status === "open");
+        if (existing)
+            return existing;
+        const dialEntry = { peerId: remote.peerId };
+        this.dialQueue.push(dialEntry);
+        try {
+            if (this.network.dialDelayMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, this.network.dialDelayMs));
+            }
+            return this._connectTo(remote);
+        }
+        finally {
+            const idx = this.dialQueue.indexOf(dialEntry);
+            if (idx !== -1)
+                this.dialQueue.splice(idx, 1);
+        }
+    }
+    async closeConnections(peer, _options) {
+        const remoteId = peer.toString();
+        const conns = this.connectionsByRemote.get(remoteId) ?? [];
+        if (conns.length === 0)
+            return;
+        // Closing one side will close the paired remote connection and notify both sides.
+        await Promise.all([...conns].map((c) => c.close()));
+    }
+    _removeConnectionInstance(remoteId, conn) {
+        const conns = this.connectionsByRemote.get(remoteId);
+        if (!conns)
+            return;
+        const idx = conns.indexOf(conn);
+        if (idx === -1)
+            return;
+        conns.splice(idx, 1);
+        if (conns.length === 0)
+            this.connectionsByRemote.delete(remoteId);
+    }
+    _connectTo(remote) {
+        const remoteKey = remote.peerId.toString();
+        const existing = this.connectionsByRemote.get(remoteKey)?.find((c) => c.status === "open");
+        if (existing)
+            return existing;
+        const addr = remote.addressManager.getAddresses()[0];
+        const connIdA = `${this.connSeqBase}->${remoteKey}:${Date.now()}:${Math.random()
+            .toString(16)
+            .slice(2)}`;
+        const connIdB = `${remoteKey}->${this.connSeqBase}:${Date.now()}:${Math.random()
+            .toString(16)
+            .slice(2)}`;
+        let connA;
+        let connB;
+        connA = new InMemoryConnection({
+            id: connIdA,
+            remotePeer: remote.peerId,
+            remoteAddr: addr,
+            getLocalRegistrar: () => this.owner.registrar,
+            getRemoteRegistrar: () => remote.registrar,
+            getRemoteConnection: () => connB,
+            recordSend: (encoded) => this.network.recordSend(this.owner.peerId, encoded),
+            shouldDrop: (encoded) => this.network.shouldDrop(encoded),
+            recordDrop: (encoded) => this.network.recordDrop(this.owner.peerId, encoded),
+            recordStreamOpen: () => {
+                this.network.metrics.streamsOpened += 1;
+            },
+            streamHighWaterMarkBytes: this.network.streamHighWaterMarkBytes,
+            streamRxDelayMs: this.network.streamRxDelayMs,
+        });
+        connB = new InMemoryConnection({
+            id: connIdB,
+            remotePeer: this.owner.peerId,
+            remoteAddr: this.owner.addressManager.getAddresses()[0],
+            getLocalRegistrar: () => remote.registrar,
+            getRemoteRegistrar: () => this.owner.registrar,
+            getRemoteConnection: () => connA,
+            recordSend: (encoded) => this.network.recordSend(remote.peerId, encoded),
+            shouldDrop: (encoded) => this.network.shouldDrop(encoded),
+            recordDrop: (encoded) => this.network.recordDrop(remote.peerId, encoded),
+            recordStreamOpen: () => {
+                this.network.metrics.streamsOpened += 1;
+            },
+            streamHighWaterMarkBytes: this.network.streamHighWaterMarkBytes,
+            streamRxDelayMs: this.network.streamRxDelayMs,
+        });
+        const pair = new InMemoryConnectionPair({
+            network: this.network,
+            aOwner: this.owner,
+            bOwner: remote,
+            aManager: this,
+            bManager: remote.connectionManager,
+            aConn: connA,
+            bConn: connB,
+        });
+        connA._setPair(pair);
+        connB._setPair(pair);
+        {
+            const arr = this.connectionsByRemote.get(remoteKey) ?? [];
+            arr.push(connA);
+            this.connectionsByRemote.set(remoteKey, arr);
+        }
+        {
+            const arr = remote.connectionManager.connectionsByRemote.get(this.owner.peerId.toString()) ?? [];
+            arr.push(connB);
+            remote.connectionManager.connectionsByRemote.set(this.owner.peerId.toString(), arr);
+        }
+        this.network.notifyConnect(this.owner, remote.peerId, connA);
+        this.network.notifyConnect(remote, this.owner.peerId, connB);
+        this.network.metrics.dials += 1;
+        this.network.metrics.connectionsOpened += 1;
+        return connA;
+    }
+}
+export class InMemoryNetwork {
+    peersById = new Map();
+    peersByPort = new Map();
+    offlineUntilByPeerId = new Map();
+    metrics = {
+        dials: 0,
+        connectionsOpened: 0,
+        connectionsClosed: 0,
+        streamsOpened: 0,
+        framesSent: 0,
+        bytesSent: 0,
+        dataFramesSent: 0,
+        ackFramesSent: 0,
+        goodbyeFramesSent: 0,
+        otherFramesSent: 0,
+        framesDropped: 0,
+        bytesDropped: 0,
+        dataFramesDropped: 0,
+    };
+    peerMetricsByHash = new Map();
+    streamHighWaterMarkBytes;
+    streamRxDelayMs;
+    dialDelayMs;
+    dropDataFrameRate;
+    dropRng;
+    constructor(opts) {
+        this.streamHighWaterMarkBytes = opts?.streamHighWaterMarkBytes ?? 256 * 1024;
+        this.streamRxDelayMs = opts?.streamRxDelayMs ?? 0;
+        this.dialDelayMs = opts?.dialDelayMs ?? 0;
+        this.dropDataFrameRate = Math.max(0, Math.min(1, Number(opts?.dropDataFrameRate ?? 0)));
+        this.dropRng = mulberry32(Number(opts?.dropSeed ?? 1));
+    }
+    isPeerOffline(peer, now = Date.now()) {
+        const key = typeof peer === "string" ? peer : peer.toString();
+        const until = this.offlineUntilByPeerId.get(key);
+        if (until == null)
+            return false;
+        if (until <= now) {
+            this.offlineUntilByPeerId.delete(key);
+            return false;
+        }
+        return true;
+    }
+    setPeerOffline(peer, downMs, now = Date.now()) {
+        const key = typeof peer === "string" ? peer : peer.toString();
+        const ms = Math.max(0, Math.floor(downMs));
+        if (ms <= 0) {
+            this.offlineUntilByPeerId.delete(key);
+            return;
+        }
+        this.offlineUntilByPeerId.set(key, now + ms);
+    }
+    setPeerOnline(peer) {
+        const key = typeof peer === "string" ? peer : peer.toString();
+        this.offlineUntilByPeerId.delete(key);
+    }
+    async disconnectPeer(peer) {
+        const key = typeof peer === "string" ? peer : peer.toString();
+        const runtime = this.getPeerById(key);
+        if (!runtime)
+            return;
+        const conns = runtime.connectionManager.getConnections();
+        await Promise.all(conns.map((c) => c.close()));
+    }
+    registerPeer(peer, port) {
+        this.peersById.set(peer.peerId.toString(), peer);
+        this.peersByPort.set(port, peer);
+    }
+    getPeerById(id) {
+        return this.peersById.get(id);
+    }
+    getPeerByPort(port) {
+        return this.peersByPort.get(port);
+    }
+    shouldDrop(encodedFrame) {
+        if (this.dropDataFrameRate <= 0)
+            return false;
+        try {
+            const { bytes } = decodeUVarint(encodedFrame);
+            const base = bytes;
+            const variant = encodedFrame[base];
+            // Only drop stream "data" frames; ACK/HELLO/etc stay reliable.
+            if (variant !== 0)
+                return false;
+            // Drop only FanoutTree payload frames (identified by message id prefix) so
+            // join/repair control traffic remains reliable under loss.
+            if (!shouldDropByMessageIdPrefix(encodedFrame, base))
+                return false;
+            // If the message has a priority, only drop low-priority payload frames.
+            // This keeps control-plane traffic (join/repair) reliable so protocols can
+            // make progress under data loss.
+            //
+            // Layout (borsh, with length prefix stripped):
+            //   [0]=DataMessage variant
+            //   [1]=MessageHeader variant
+            //   [2..33]=id (32 bytes)
+            //   [34..41]=timestamp (u64)
+            //   [42..49]=session (u64)
+            //   [50..57]=expires (u64)
+            //   [58]=priority option flag (u8)
+            //   [59..62]=priority (u32 LE) if flag=1
+            const flagOffset = base + 58;
+            const hasPriority = encodedFrame[flagOffset];
+            if (hasPriority === 1) {
+                const prio = readU32LE(encodedFrame, flagOffset + 1);
+                if (prio > 1)
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        return this.dropRng() < this.dropDataFrameRate;
+    }
+    recordDrop(fromPeerId, encodedFrame) {
+        this.metrics.framesDropped += 1;
+        this.metrics.bytesDropped += encodedFrame.byteLength;
+        const fromHash = getPublicKeyFromPeerId(fromPeerId).hashcode();
+        let pm = this.peerMetricsByHash.get(fromHash);
+        if (!pm) {
+            pm = {
+                framesSent: 0,
+                bytesSent: 0,
+                dataFramesSent: 0,
+                ackFramesSent: 0,
+                goodbyeFramesSent: 0,
+                otherFramesSent: 0,
+                framesDropped: 0,
+                bytesDropped: 0,
+                dataFramesDropped: 0,
+                maxBytesPerSecond: 0,
+                _currentSecond: -1,
+                _bytesThisSecond: 0,
+            };
+            this.peerMetricsByHash.set(fromHash, pm);
+        }
+        pm.framesDropped += 1;
+        pm.bytesDropped += encodedFrame.byteLength;
+        this.metrics.dataFramesDropped += 1;
+        pm.dataFramesDropped += 1;
+    }
+    recordSend(fromPeerId, encodedFrame) {
+        this.metrics.framesSent += 1;
+        this.metrics.bytesSent += encodedFrame.byteLength;
+        const fromHash = getPublicKeyFromPeerId(fromPeerId).hashcode();
+        let pm = this.peerMetricsByHash.get(fromHash);
+        if (!pm) {
+            pm = {
+                framesSent: 0,
+                bytesSent: 0,
+                dataFramesSent: 0,
+                ackFramesSent: 0,
+                goodbyeFramesSent: 0,
+                otherFramesSent: 0,
+                framesDropped: 0,
+                bytesDropped: 0,
+                dataFramesDropped: 0,
+                maxBytesPerSecond: 0,
+                _currentSecond: -1,
+                _bytesThisSecond: 0,
+            };
+            this.peerMetricsByHash.set(fromHash, pm);
+        }
+        pm.framesSent += 1;
+        pm.bytesSent += encodedFrame.byteLength;
+        const sec = Math.floor(Date.now() / 1000);
+        if (pm._currentSecond !== sec) {
+            pm._currentSecond = sec;
+            pm._bytesThisSecond = 0;
+        }
+        pm._bytesThisSecond += encodedFrame.byteLength;
+        if (pm._bytesThisSecond > pm.maxBytesPerSecond) {
+            pm.maxBytesPerSecond = pm._bytesThisSecond;
+        }
+        try {
+            const { bytes } = decodeUVarint(encodedFrame);
+            const variant = encodedFrame[bytes];
+            if (variant === 0)
+                this.metrics.dataFramesSent += 1;
+            else if (variant === 1)
+                this.metrics.ackFramesSent += 1;
+            else if (variant === 3)
+                this.metrics.goodbyeFramesSent += 1;
+            else
+                this.metrics.otherFramesSent += 1;
+            if (variant === 0)
+                pm.dataFramesSent += 1;
+            else if (variant === 1)
+                pm.ackFramesSent += 1;
+            else if (variant === 3)
+                pm.goodbyeFramesSent += 1;
+            else
+                pm.otherFramesSent += 1;
+        }
+        catch {
+            this.metrics.otherFramesSent += 1;
+            pm.otherFramesSent += 1;
+        }
+    }
+    notifyConnect(owner, peerId, connection) {
+        const remote = this.getPeerById(peerId.toString());
+        for (const { protocol, topology } of owner.registrar.getTopologies()) {
+            if (remote && !remote.registrar.getHandler(protocol))
+                continue;
+            topology.onConnect(peerId, connection);
+        }
+    }
+    notifyDisconnect(owner, peerId, connections) {
+        const remote = this.getPeerById(peerId.toString());
+        for (const conn of connections) {
+            for (const { protocol, topology } of owner.registrar.getTopologies()) {
+                if (remote && !remote.registrar.getHandler(protocol))
+                    continue;
+                topology.onDisconnect(peerId, conn);
+            }
+        }
+    }
+    static createPeer(opts) {
+        // Use deterministic-but-valid ed25519 keys (derived from index seed).
+        // This keeps sims reproducible while still allowing Peerbit's keychain
+        // to derive x25519 keys (libsodium rejects invalid points).
+        const seed = (() => {
+            const out = new Uint8Array(32);
+            let x = Math.imul((opts.index >>> 0) + 1, 0x9e3779b1) >>> 0;
+            for (let i = 0; i < out.length; i++) {
+                x ^= x >>> 16;
+                x = Math.imul(x, 0x7feb352d) >>> 0;
+                x ^= x >>> 15;
+                x = Math.imul(x, 0x846ca68b) >>> 0;
+                x ^= x >>> 16;
+                out[i] = x & 0xff;
+            }
+            return out;
+        })();
+        const generated = opts.mockKeyBytes
+            ? { publicKey: opts.mockKeyBytes.publicKey, privateKey: opts.mockKeyBytes.privateKey }
+            : sodium.crypto_sign_seed_keypair(seed);
+        const pub = generated.publicKey;
+        const priv = generated.privateKey;
+        const peerId = {
+            type: "Ed25519",
+            publicKey: { raw: pub },
+            toString: () => `sim-${opts.index}`,
+            equals: (other) => other?.toString?.() === `sim-${opts.index}`,
+        };
+        const privateKey = {
+            type: "Ed25519",
+            raw: priv,
+            publicKey: { raw: pub },
+        };
+        const addr = multiaddr(`/ip4/127.0.0.1/tcp/${opts.port}`);
+        const registrar = new InMemoryRegistrar();
+        const addressManager = new InMemoryAddressManager(addr);
+        const peerStore = new InMemoryPeerStore((peerId) => {
+            const network = opts.network;
+            const runtime = network?.getPeerById(peerId.toString());
+            return runtime?.addressManager.getAddresses() ?? [];
+        });
+        const events = new EventTarget();
+        // placeholder connectionManager; caller wires it after creation
+        const runtime = {
+            peerId,
+            privateKey,
+            registrar,
+            addressManager,
+            peerStore,
+            events,
+            connectionManager: undefined,
+        };
+        return { runtime: runtime, port: opts.port };
+    }
+}
+export const publicKeyHash = (peerId) => getPublicKeyFromPeerId(peerId).hashcode();
+export class InMemoryLibp2p {
+    runtime;
+    status = "stopped";
+    peerId;
+    services;
+    components;
+    constructor(runtime, services) {
+        this.runtime = runtime;
+        this.peerId = runtime.peerId;
+        this.components = {
+            peerId: runtime.peerId,
+            privateKey: runtime.privateKey,
+            addressManager: runtime.addressManager,
+            registrar: runtime.registrar,
+            connectionManager: runtime.connectionManager,
+            peerStore: runtime.peerStore,
+            events: runtime.events,
+        };
+        const out = {};
+        if (services) {
+            for (const [name, factory] of Object.entries(services)) {
+                out[name] = factory(this.components);
+            }
+        }
+        this.services = out;
+    }
+    getMultiaddrs() {
+        return this.runtime.addressManager.getAddresses();
+    }
+    dial(addresses) {
+        return this.runtime.connectionManager.openConnection(addresses);
+    }
+    hangUp(peerId, options) {
+        return this.runtime.connectionManager.closeConnections(peerId, options);
+    }
+    getConnections(peerId) {
+        return this.runtime.connectionManager.getConnections(peerId);
+    }
+    async start() {
+        if (this.status === "started")
+            return;
+        this.status = "started";
+        await Promise.all(Object.values(this.services).map((svc) => svc?.start?.()));
+    }
+    async stop() {
+        if (this.status === "stopped")
+            return;
+        this.status = "stopped";
+        await Promise.all(Object.values(this.services).map((svc) => svc?.stop?.()));
+        const conns = this.runtime.connectionManager.getConnections();
+        await Promise.all(conns.map((c) => c.close()));
+    }
+}
+export class InMemorySession {
+    peers;
+    network;
+    constructor(opts) {
+        this.peers = opts.peers;
+        this.network = opts.network;
+    }
+    static async disconnected(n, opts) {
+        await sodium.ready;
+        const network = opts?.network ?? new InMemoryNetwork(opts?.networkOpts);
+        const basePort = opts?.basePort ?? 30_000;
+        const peers = [];
+        for (let i = 0; i < n; i++) {
+            const port = basePort + i;
+            const { runtime } = InMemoryNetwork.createPeer({ index: i, port, network });
+            runtime.connectionManager = new InMemoryConnectionManager(network, runtime);
+            network.registerPeer(runtime, port);
+            peers.push(new InMemoryLibp2p(runtime, opts?.services));
+        }
+        const session = new InMemorySession({ peers, network });
+        if (opts?.start !== false) {
+            await Promise.all(session.peers.map((p) => p.start()));
+        }
+        return session;
+    }
+    async connectFully(groups) {
+        const peers = groups ?? [this.peers];
+        const connectPromises = [];
+        for (const group of peers) {
+            for (let i = 0; i < group.length - 1; i++) {
+                for (let j = i + 1; j < group.length; j++) {
+                    connectPromises.push(group[i].dial(group[j].getMultiaddrs()));
+                }
+            }
+        }
+        await Promise.all(connectPromises);
+        return this;
+    }
+    async stop() {
+        await Promise.all(this.peers.map((p) => p.stop()));
+    }
+}
+//# sourceMappingURL=inmemory-libp2p.js.map