@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/core/networking/peers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peers.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/peers.test.ts"],"names":[],"mappings":""}

package/packages/core/networking/peers.test.js

@@ -0,0 +1,83 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { OK } from "#@typeberry/utils";
+import { PeersManagement } from "./peers.js";
+import { createDisconnectedPeer } from "./testing.js";
+describe("Peers", () => {
+    it("should track peer connection status", () => {
+        const peers = new PeersManagement();
+        const peer = createDisconnectedPeer("test-peer-1");
+        assert.strictEqual(peers.isConnected(peer.id), false);
+        assert.strictEqual(peers.noOfConnectedPeers(), 0);
+        peers.peerConnected(peer);
+        assert.strictEqual(peers.isConnected(peer.id), true);
+        assert.strictEqual(peers.noOfConnectedPeers(), 1);
+        peers.peerDisconnected(peer);
+        assert.strictEqual(peers.isConnected(peer.id), false);
+        assert.strictEqual(peers.noOfConnectedPeers(), 0);
+    });
+    it("should call connection callbacks", () => {
+        const peers = new PeersManagement();
+        const peer = createDisconnectedPeer("test-peer-2");
+        let connectedCalled = false;
+        let disconnectedCalled = false;
+        peers.onPeerConnected(() => {
+            connectedCalled = true;
+            return OK;
+        });
+        peers.onPeerDisconnected(() => {
+            disconnectedCalled = true;
+            return OK;
+        });
+        assert.strictEqual(connectedCalled, false);
+        peers.peerConnected(peer);
+        assert.strictEqual(connectedCalled, true);
+        assert.strictEqual(disconnectedCalled, false);
+        peers.peerDisconnected(peer);
+        assert.strictEqual(disconnectedCalled, true);
+    });
+    it("should handle multiple callbacks", () => {
+        const peers = new PeersManagement();
+        const peer = createDisconnectedPeer("test-peer-3");
+        let callback1Called = false;
+        let callback2Called = false;
+        peers.onPeerConnected(() => {
+            callback1Called = true;
+            return OK;
+        });
+        peers.onPeerConnected(() => {
+            callback2Called = true;
+            return OK;
+        });
+        peers.peerConnected(peer);
+        assert.strictEqual(callback1Called, true);
+        assert.strictEqual(callback2Called, true);
+    });
+    it("should allow callback removal", () => {
+        const peers = new PeersManagement();
+        const peer = createDisconnectedPeer("test-peer-4");
+        let callbackCalled = false;
+        const removeCallback = peers.onPeerConnected(() => {
+            callbackCalled = true;
+            return OK;
+        });
+        removeCallback();
+        peers.peerConnected(peer);
+        assert.strictEqual(callbackCalled, false);
+    });
+    it("should replace existing peer with same ID", () => {
+        const peers = new PeersManagement();
+        const peer1 = createDisconnectedPeer("same-id", "127.0.0.1", 8080);
+        const peer2 = createDisconnectedPeer("same-id", "127.0.0.1", 8081);
+        assert.strictEqual(peers.isConnected(peer1.id), false);
+        peers.peerConnected(peer1);
+        assert.strictEqual(peers.isConnected(peer1.id), true);
+        assert.strictEqual(peers.noOfConnectedPeers(), 1);
+        // since the second peer has exactly the same id we
+        // just replace the place info and assume it is still connected.
+        peers.peerConnected(peer2);
+        assert.strictEqual(peers.isConnected(peer1.id), true);
+        assert.strictEqual(peers.isConnected(peer2.id), true);
+        assert.strictEqual(peers.noOfConnectedPeers(), 1);
+    });
+});

package/packages/core/networking/quic-network.d.ts

@@ -0,0 +1,22 @@
+import type { QUICServer, QUICSocket } from "@matrixai/quic";
+import type { DialOptions, Network } from "./network.js";
+import type { PeerAddress, Peers, PeersManagement } from "./peers.js";
+import type { QuicPeer } from "./quic-peer.js";
+export declare class QuicNetwork implements Network<QuicPeer> {
+    private readonly socket;
+    private readonly server;
+    private readonly _dial;
+    private readonly _peers;
+    private readonly listen;
+    private started;
+    constructor(socket: QUICSocket, server: QUICServer, _dial: (peer: PeerAddress, options: DialOptions) => Promise<QuicPeer>, _peers: PeersManagement<QuicPeer>, listen: {
+        host: string;
+        port: number;
+    });
+    get isRunning(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    get peers(): Peers<QuicPeer>;
+    dial(peer: PeerAddress, options?: DialOptions): Promise<QuicPeer>;
+}
+//# sourceMappingURL=quic-network.d.ts.map

package/packages/core/networking/quic-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic-network.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/quic-network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,qBAAa,WAAY,YAAW,OAAO,CAAC,QAAQ,CAAC;IAIjD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,OAAO,CAAS;gBAGL,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,EACrE,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,EACjC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAGzD,IAAI,SAAS,YAEZ;IAEK,KAAK;IAYL,IAAI;IAYV,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,CAAC,CAE3B;IAEK,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;CAG5E"}

package/packages/core/networking/quic-network.js

@@ -0,0 +1,46 @@
+import { Logger } from "#@typeberry/logger";
+const logger = Logger.new(import.meta.filename, "net");
+export class QuicNetwork {
+    socket;
+    server;
+    _dial;
+    _peers;
+    listen;
+    started = false;
+    constructor(socket, server, _dial, _peers, listen) {
+        this.socket = socket;
+        this.server = server;
+        this._dial = _dial;
+        this._peers = _peers;
+        this.listen = listen;
+    }
+    get isRunning() {
+        return this.started;
+    }
+    async start() {
+        if (this.started) {
+            throw new Error("Network already started!");
+        }
+        this.started = true;
+        await this.socket.start({ host: this.listen.host, port: this.listen.port });
+        logger.info `🛜  QUIC socket on ${this.socket.host}:${this.socket.port}`;
+        await this.server.start();
+        logger.log `🛜  QUIC server listening`;
+    }
+    async stop() {
+        if (!this.started) {
+            throw new Error("Network not started yet!");
+        }
+        logger.info `Stopping the networking.`;
+        await this.server.stop();
+        await this.socket.stop();
+        this.started = false;
+        logger.info `Networking stopped.`;
+    }
+    get peers() {
+        return this._peers;
+    }
+    async dial(peer, options = {}) {
+        return this._dial(peer, options);
+    }
+}

package/packages/core/networking/quic-peer.d.ts

@@ -0,0 +1,18 @@
+import { type QUICConnection } from "@matrixai/quic";
+import type { Ed25519Key } from "#@typeberry/crypto";
+import type { PeerInfo } from "./certificate.js";
+import type { Peer, PeerAddress, PeerId, StreamCallback } from "./peers.js";
+import { QuicStream } from "./quic-stream.js";
+export declare class QuicPeer implements Peer {
+    readonly conn: QUICConnection;
+    readonly connectionId: string;
+    readonly address: PeerAddress;
+    readonly id: PeerId;
+    readonly key: Ed25519Key;
+    private readonly streamEvents;
+    constructor(conn: QUICConnection, peerInfo: PeerInfo);
+    addOnIncomingStream(streamCallback: StreamCallback<QuicStream>): void;
+    openStream(): QuicStream;
+    disconnect(): Promise<void>;
+}
+//# sourceMappingURL=quic-peer.d.ts.map

package/packages/core/networking/quic-peer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic-peer.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/quic-peer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAK9C,qBAAa,QAAS,YAAW,IAAI;aAQjB,IAAI,EAAE,cAAc;IAPtC,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,OAAO,EAAE,WAAW,CAAC;IACrC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,GAAG,EAAE,UAAU,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;gBAGjC,IAAI,EAAE,cAAc,EACpC,QAAQ,EAAE,QAAQ;IAuBpB,mBAAmB,CAAC,cAAc,EAAE,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI;IAIrE,UAAU,IAAI,UAAU;IAMlB,UAAU;CAIjB"}

package/packages/core/networking/quic-peer.js

@@ -0,0 +1,45 @@
+import EventEmitter from "node:events";
+import { events } from "@matrixai/quic";
+import { Logger } from "#@typeberry/logger";
+import { QuicStream } from "./quic-stream.js";
+import { addEventListener } from "./quic-utils.js";
+const logger = Logger.new(import.meta.filename, "peers");
+export class QuicPeer {
+    conn;
+    connectionId;
+    address;
+    id;
+    key;
+    streamEvents = new EventEmitter();
+    constructor(conn, peerInfo) {
+        this.conn = conn;
+        logger.log `👥 [${peerInfo.id}] peer connected ${conn.remoteHost}:${conn.remotePort}`;
+        this.connectionId = conn.connectionIdShared.toString();
+        this.address = {
+            host: conn.remoteHost,
+            port: conn.remotePort,
+        };
+        this.id = peerInfo.id;
+        this.key = peerInfo.key;
+        addEventListener(conn, events.EventQUICConnectionStream, (ev) => {
+            const stream = ev.detail;
+            logger.log `🚰  [${this.id}] new stream: [${stream.streamId}]`;
+            this.streamEvents.emit("stream", new QuicStream(stream));
+        });
+        addEventListener(conn, events.EventQUICConnectionError, (err) => {
+            logger.error `❌ [${this.id}] connection failed: ${err.detail}`;
+        });
+    }
+    addOnIncomingStream(streamCallback) {
+        this.streamEvents.on("stream", streamCallback);
+    }
+    openStream() {
+        const stream = this.conn.newStream("bidi");
+        logger.log `🚰 [${this.id}] opening stream: [${stream.streamId}]`;
+        return new QuicStream(stream);
+    }
+    async disconnect() {
+        logger.log `👋 [${this.id}] disconnecting`;
+        await this.conn.stop({ isApp: true });
+    }
+}

package/packages/core/networking/quic-stream.d.ts

@@ -0,0 +1,13 @@
+import { type QUICStream } from "@matrixai/quic";
+import { type Stream, type StreamErrorCallback } from "./peers.js";
+/** `QUICStream` adapter for our `Stream` API. */
+export declare class QuicStream implements Stream {
+    readonly stream: QUICStream;
+    constructor(stream: QUICStream);
+    get streamId(): import("@matrixai/quic").StreamId;
+    get readable(): import("stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>;
+    get writable(): import("stream/web").WritableStream<Uint8Array<ArrayBufferLike>>;
+    addOnError(onError: StreamErrorCallback): void;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=quic-stream.d.ts.map

package/packages/core/networking/quic-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic-stream.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/quic-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,mBAAmB,EAAmB,MAAM,YAAY,CAAC;AAGpF,iDAAiD;AACjD,qBAAa,UAAW,YAAW,MAAM;aACX,MAAM,EAAE,UAAU;gBAAlB,MAAM,EAAE,UAAU;IAE9C,IAAI,QAAQ,sCAEX;IAED,IAAI,QAAQ,qEAEX;IAED,IAAI,QAAQ,qEAEX;IAED,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAmB9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGzB"}

package/packages/core/networking/quic-stream.js

@@ -0,0 +1,36 @@
+import { errors, events } from "@matrixai/quic";
+import { StreamErrorKind } from "./peers.js";
+import { addEventListener } from "./quic-utils.js";
+/** `QUICStream` adapter for our `Stream` API. */
+export class QuicStream {
+    stream;
+    constructor(stream) {
+        this.stream = stream;
+    }
+    get streamId() {
+        return this.stream.streamId;
+    }
+    get readable() {
+        return this.stream.readable;
+    }
+    get writable() {
+        return this.stream.writable;
+    }
+    addOnError(onError) {
+        addEventListener(this.stream, events.EventQUICStreamError, (e) => {
+            const isLocalClose = e.detail instanceof errors.ErrorQUICStreamLocalRead ||
+                e.detail instanceof errors.ErrorQUICStreamLocalWrite ||
+                e.detail instanceof errors.ErrorQUICConnectionLocal;
+            const isRemoteClose = e.detail instanceof errors.ErrorQUICConnectionPeer;
+            const kind = isLocalClose
+                ? StreamErrorKind.LocalClose
+                : isRemoteClose
+                    ? StreamErrorKind.RemoteClose
+                    : StreamErrorKind.Exception;
+            onError(e.detail, kind);
+        });
+    }
+    destroy() {
+        return this.stream.destroy();
+    }
+}

package/packages/core/networking/quic-utils.d.ts

@@ -0,0 +1,5 @@
+import type { QUICClient, QUICConnection, QUICServer, QUICStream } from "@matrixai/quic";
+export declare function addEventListener<T extends Event>(target: QUICServer | QUICClient | QUICConnection | QUICStream, clazz: {
+    new (...args: any[]): T;
+}, callback: (ev: T) => void | Promise<void>): void;
+//# sourceMappingURL=quic-utils.d.ts.map

package/packages/core/networking/quic-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/quic-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAKzF,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,KAAK,EAC9C,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,UAAU,EAE7D,KAAK,EAAE;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,EAClC,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,QAS1C"}

package/packages/core/networking/quic-utils.js

@@ -0,0 +1,14 @@
+import { Logger } from "#@typeberry/logger";
+const logger = Logger.new(import.meta.filename, "net");
+export function addEventListener(target, 
+// biome-ignore lint/suspicious/noExplicitAny: any is used here to match all possible event constructors.
+clazz, callback) {
+    target.addEventListener(clazz.name, async (ev) => {
+        try {
+            await callback(ev);
+        }
+        catch (e) {
+            logger.error `Unhandled exception in ${clazz.name} event handler: ${e}`;
+        }
+    });
+}

package/packages/core/networking/setup.d.ts

@@ -0,0 +1,18 @@
+import type { Ed25519Pair } from "#@typeberry/crypto/ed25519.js";
+import { QuicNetwork } from "./quic-network.js";
+/** Networking server part options. */
+export type Options = {
+    /** Peer's ed25519key. */
+    key: Ed25519Pair;
+    /** Host interface to bound to. */
+    host: string;
+    /** Port to listen on. Use `0` for random. */
+    port: number;
+    /** Supported ALPNs (protocols) both for the inbound and outbound connections. */
+    protocols: string[];
+};
+export declare class Quic {
+    /** Setup QUIC socket and start listening for connections. */
+    static setup({ host, port, protocols, key }: Options): Promise<QuicNetwork>;
+}
+//# sourceMappingURL=setup.d.ts.map

package/packages/core/networking/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/setup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAgBhE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMhD,sCAAsC;AACtC,MAAM,MAAM,OAAO,GAAG;IACpB,yBAAyB;IACzB,GAAG,EAAE,WAAW,CAAC;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAQF,qBAAa,IAAI;IACf,6DAA6D;WAChD,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC;CAkKlF"}

package/packages/core/networking/setup.js

@@ -0,0 +1,156 @@
+import QuicLogger, { formatting, LogLevel, StreamHandler } from "@matrixai/logger";
+import { events, QUICClient, QUICServer, QUICSocket } from "@matrixai/quic";
+import { BytesBlob } from "#@typeberry/bytes";
+import { Level, Logger } from "#@typeberry/logger";
+import { now } from "#@typeberry/utils";
+import { altNameRaw, certToPEM, ed25519AsJsonWebKeyPair, generateCertificate, privateKeyToPEM, } from "./certificate.js";
+import { getQuicClientCrypto, getQuicServerCrypto } from "./crypto.js";
+import * as metrics from "./metrics.js";
+import { peerVerification } from "./peer-verification.js";
+import { PeersManagement } from "./peers.js";
+import { QuicNetwork } from "./quic-network.js";
+import { QuicPeer } from "./quic-peer.js";
+import { addEventListener } from "./quic-utils.js";
+const logger = Logger.new(import.meta.filename, "net");
+var CloseReason;
+(function (CloseReason) {
+    CloseReason[CloseReason["PeerIdMismatch"] = 0] = "PeerIdMismatch";
+    CloseReason[CloseReason["DuplicateConnection"] = 1] = "DuplicateConnection";
+    CloseReason[CloseReason["ConnectionFromOurself"] = 2] = "ConnectionFromOurself";
+})(CloseReason || (CloseReason = {}));
+export class Quic {
+    /** Setup QUIC socket and start listening for connections. */
+    static async setup({ host, port, protocols, key }) {
+        const networkMetrics = metrics.createMetrics();
+        const quicLoggerLvl = logger.getLevel() > Level.TRACE ? LogLevel.WARN : LogLevel.DEBUG;
+        const quicLogger = new QuicLogger("quic", quicLoggerLvl, [
+            new StreamHandler(formatting.format `${formatting.level}:${formatting.keys}:${formatting.msg}`),
+        ]);
+        // Load keypair
+        const keyPair = ed25519AsJsonWebKeyPair(key);
+        const privKeyPEM = await privateKeyToPEM(keyPair);
+        const cert = await generateCertificate({
+            certId: BytesBlob.blobFromString("QUIC Networking"),
+            subjectKeyPair: keyPair,
+            issuerKeyPair: keyPair,
+        });
+        const lastConnectedPeer = peerVerification();
+        // QUICConfig
+        const config = {
+            keepAliveIntervalTime: 3000,
+            maxIdleTimeout: 6000,
+            applicationProtos: protocols,
+            cert: certToPEM(cert),
+            key: privKeyPEM,
+            verifyPeer: true,
+            verifyCallback: lastConnectedPeer.verifyCallback,
+        };
+        logger.info `🆔 Peer id: ** ${altNameRaw(key.pubKey)}@${host}:${port} ** (pubkey: ${key.pubKey})`;
+        // Shared injected UDP socket
+        const socket = new QUICSocket({
+            logger: quicLogger.getChild("socket"),
+        });
+        // Start server on the socket.
+        const server = new QUICServer({
+            socket,
+            config,
+            crypto: getQuicServerCrypto(key),
+            logger: quicLogger.getChild("server"),
+        });
+        // peer management
+        const peers = new PeersManagement();
+        // basic error handling
+        addEventListener(server, events.EventQUICServerError, (error) => logger.error `🛜  Server error: ${error}`);
+        addEventListener(server, events.EventQUICServerClose, (ev) => logger.error `🛜  Server stopped: ${ev}`);
+        // handling incoming session
+        addEventListener(server, events.EventQUICServerConnection, async (ev) => {
+            const conn = ev.detail;
+            const peerAddress = `${conn.remoteHost}:${conn.remotePort}`;
+            networkMetrics.recordConnectingIn(peerAddress);
+            if (lastConnectedPeer.info === null) {
+                networkMetrics.recordConnectInFailed("no_peer_info");
+                await conn.stop();
+                return;
+            }
+            if (lastConnectedPeer.info.key.isEqualTo(key.pubKey)) {
+                logger.log `🛜 Rejecting connection from ourself from ${conn.remoteHost}:${conn.remotePort}`;
+                networkMetrics.recordConnectionRefused(peerAddress);
+                await conn.stop({ isApp: true, errorCode: CloseReason.ConnectionFromOurself });
+                return;
+            }
+            if (peers.isConnected(lastConnectedPeer.info.id)) {
+                logger.log `🛜 Rejecting duplicate connection with peer ${lastConnectedPeer.info.id} from ${conn.remoteHost}:${conn.remotePort}`;
+                networkMetrics.recordConnectionRefused(peerAddress);
+                await conn.stop({ isApp: true, errorCode: CloseReason.DuplicateConnection });
+                return;
+            }
+            logger.log `🛜 Server handshake with ${conn.remoteHost}:${conn.remotePort}`;
+            newPeer(conn, lastConnectedPeer.info, "in");
+            networkMetrics.recordConnectedIn(lastConnectedPeer.info.id);
+            lastConnectedPeer.info = null;
+            await conn.start();
+        });
+        // connecting to a peer
+        async function dial(peer, options) {
+            return doDial();
+            async function doDial() {
+                const peerAddress = `${peer.host}:${peer.port}`;
+                const peerDetails = peerVerification();
+                try {
+                    const clientLater = QUICClient.createQUICClient({
+                        socket: socket,
+                        host: peer.host,
+                        port: peer.port,
+                        crypto: getQuicClientCrypto(),
+                        config: {
+                            ...config,
+                            verifyCallback: peerDetails.verifyCallback,
+                        },
+                        logger: quicLogger.getChild("client"),
+                    }, {
+                        signal: options.signal,
+                    });
+                    const client = await clientLater;
+                    networkMetrics.recordConnectingOut(peerDetails.info?.id ?? "unknown", peerAddress);
+                    if (peerDetails.info === null) {
+                        networkMetrics.recordConnectOutFailed("no_peer_info");
+                        await client.destroy({ isApp: true, errorCode: CloseReason.PeerIdMismatch });
+                        throw new Error("Client connected, but there is no peer details!");
+                    }
+                    if (options.verifyName !== undefined && options.verifyName !== peerDetails.info.id) {
+                        networkMetrics.recordConnectOutFailed("peer_id_mismatch");
+                        await client.destroy({ isApp: true, errorCode: CloseReason.PeerIdMismatch });
+                        throw new Error(`Client connected, but the id didn't match. Expected: ${options.verifyName}, got: ${peerDetails.info.id}`);
+                    }
+                    addEventListener(client, events.EventQUICClientClose, () => {
+                        logger.log `⚰️ Client connection closed.`;
+                    });
+                    addEventListener(client, events.EventQUICClientError, (error) => {
+                        logger.error `🔴 Client error: ${error.detail}`;
+                    });
+                    logger.log `🤝 Client handshake with: ${peer.host}:${peer.port}`;
+                    const newPeerInstance = newPeer(client.connection, peerDetails.info, "out");
+                    networkMetrics.recordConnectedOut(peerDetails.info.id);
+                    return newPeerInstance;
+                }
+                catch (error) {
+                    networkMetrics.recordConnectOutFailed(String(error));
+                    throw error;
+                }
+            }
+        }
+        function newPeer(conn, peerInfo, side) {
+            const peer = new QuicPeer(conn, peerInfo);
+            const connectionStartTime = now();
+            addEventListener(peer.conn, events.EventQUICConnectionClose, (ev) => {
+                const duration = now() - connectionStartTime;
+                const reason = String(ev.detail) ?? "normal";
+                networkMetrics.recordDisconnected(peer.id, side, reason, duration);
+                peers.peerDisconnected(peer);
+            });
+            peers.peerConnected(peer);
+            return peer;
+        }
+        return new QuicNetwork(socket, server, dial, peers, { host, port });
+    }
+}

package/packages/core/networking/testing.d.ts

@@ -0,0 +1,91 @@
+import { type ReadableStream, WritableStream } from "node:stream/web";
+import { type Ed25519Key } from "#@typeberry/crypto";
+import type { DialOptions, Network } from "./network.js";
+import { type Peer, type PeerAddress, type PeerId, PeersManagement, type Stream, type StreamCallback, type StreamErrorCallback } from "./peers.js";
+/**
+ * Stream implementation that allows manual control over
+ * received and sent bytes.
+ */
+export declare class TestManualStream implements Stream {
+    readonly streamId: number;
+    readonly writable: WritableStream;
+    readonly readable: ReadableStream;
+    readonly _writtenData: Uint8Array[];
+    readonly _incomingData: WritableStream;
+    private readonly _onError;
+    constructor(streamId: number);
+    addOnError(onError: StreamErrorCallback): void;
+    destroy(): Promise<void>;
+    _simulateIncomingData(kindData: Uint8Array): void;
+}
+export declare class TestDuplexStream implements Stream {
+    readonly streamId: number;
+    readonly readable: ReadableStream;
+    readonly writable: WritableStream;
+    static pair(id: number): readonly [TestDuplexStream, TestDuplexStream];
+    _onError: StreamErrorCallback[];
+    addOnError(onError: StreamErrorCallback): void;
+    constructor(streamId: number, readable: ReadableStream, writable: WritableStream);
+    destroy(): Promise<void>;
+}
+/**
+ * A representation of some remote peer, that's actually
+ * coupled with another instance of `TestPeer`.
+ *
+ * This allows us to have two peers connected together,
+ * so that when one opens a stream, the other one
+ * receives a callback about new stream being opened, etc.
+ */
+export declare class TestPeer implements Peer {
+    _streamId: number;
+    readonly connectionId: string;
+    readonly address: PeerAddress;
+    readonly id: PeerId;
+    readonly key: Ed25519Key;
+    static pairUp(a: TestPeer, b: TestPeer): readonly [TestPeer, TestPeer];
+    private readonly _onIncomingStreams;
+    private _otherPeer;
+    constructor(_streamId: number, connectionId: string, address: PeerAddress, id: PeerId, key: Ed25519Key);
+    addOnIncomingStream(streamCallback: StreamCallback): void;
+    openStream(): Stream;
+    disconnect(): Promise<void>;
+}
+export declare class TestPeerDisconnected implements Peer {
+    readonly connectionId: string;
+    readonly address: PeerAddress;
+    readonly id: PeerId;
+    readonly key: Ed25519Key;
+    _streamId: number;
+    private readonly _onIncomingStreams;
+    readonly _openedStreams: TestManualStream[];
+    _disconnectCalled: boolean;
+    constructor(connectionId: string, address: PeerAddress, id: PeerId, key: Ed25519Key);
+    addOnIncomingStream(streamCallback: StreamCallback): void;
+    openStream(): Stream;
+    disconnect(): Promise<void>;
+}
+/**
+ * Create a standalone test peer, that allows fine-grained control over the received
+ * and sent data.
+ */
+export declare function createDisconnectedPeer(id: string, host?: string, port?: number): TestPeerDisconnected;
+/**
+ * Creates two peer objects that are interconnected - sending data
+ * over `writable` of one peer, will cause it to be receied on
+ * `readable` on the other peer and vice-versa.
+ */
+export declare function createTestPeerPair(streamIdx: number, id1: string, id2: string): readonly [TestPeer, TestPeer];
+/**
+ * Mock Network implementation for testing
+ * Provides controlled peer connection/disconnection simulation
+ */
+export declare class MockNetwork implements Network<Peer> {
+    readonly name: string;
+    readonly _peers: PeersManagement<Peer>;
+    constructor(name: string);
+    get peers(): PeersManagement<Peer>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dial(address: PeerAddress, _options: DialOptions): Promise<Peer>;
+}
+//# sourceMappingURL=testing.d.ts.map

package/packages/core/networking/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/testing.ts"],"names":[],"mappings":"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"}