@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/mmr/index.js

@@ -0,0 +1,118 @@
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
+/**
+ * Merkle Mountain Range.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/3aa0023aa002?v=0.6.2
+ */
+export class MerkleMountainRange {
+    hasher;
+    mountains;
+    /** Construct an empty MMR. */
+    static empty(hasher) {
+        return new MerkleMountainRange(hasher);
+    }
+    /** Construct a new MMR from existing peaks. */
+    static fromPeaks(hasher, mmr) {
+        return new MerkleMountainRange(hasher, mmr.peaks
+            .reduce((acc, peak, index) => {
+            if (peak !== null) {
+                acc.push(Mountain.fromPeak(peak, 2 ** index));
+            }
+            return acc;
+        }, [])
+            .reverse());
+    }
+    constructor(hasher, 
+    /** Store non-empty merkle tries (mountains) ordered by descending size. */
+    mountains = []) {
+        this.hasher = hasher;
+        this.mountains = mountains;
+    }
+    /**
+     * Append a new hash to the MMR structure.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/3b11003b1100?v=0.6.2
+     */
+    append(hash) {
+        let newMountain = Mountain.fromPeak(hash, 1);
+        for (;;) {
+            const last = this.mountains.pop();
+            if (last === undefined) {
+                this.mountains.push(newMountain);
+                return;
+            }
+            if (last.size !== newMountain.size) {
+                this.mountains.push(last);
+                this.mountains.push(newMountain);
+                return;
+            }
+            newMountain = last.mergeWith(this.hasher, newMountain);
+        }
+    }
+    /**
+     * Root of the entire structure.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/3b20013b2001?v=0.6.2
+     */
+    getSuperPeakHash() {
+        if (this.mountains.length === 0) {
+            return Bytes.zero(HASH_SIZE).asOpaque();
+        }
+        const revMountains = this.mountains.slice().reverse();
+        const length = revMountains.length;
+        let lastHash = revMountains[0].peak;
+        for (let i = 1; i < length; i++) {
+            const mountain = revMountains[i];
+            lastHash = this.hasher.hashConcatPrepend(SUPER_PEAK_STRING, lastHash, mountain.peak);
+        }
+        return lastHash;
+    }
+    /** Get current peaks. */
+    getPeaks() {
+        const peaks = [];
+        const mountains = this.mountains;
+        // always 2**index
+        let currentSize = 1;
+        let currentIdx = mountains.length - 1;
+        while (currentIdx >= 0) {
+            const currentItem = mountains[currentIdx];
+            if (currentItem.size >= currentSize && currentItem.size < 2 * currentSize) {
+                peaks.push(currentItem.peak);
+                currentIdx -= 1;
+            }
+            else {
+                peaks.push(null);
+            }
+            // move to the next index.
+            currentSize = currentSize << 1;
+        }
+        return { peaks };
+    }
+}
+/** An internal helper structure to represent a merkle trie for MMR. */
+class Mountain {
+    peak;
+    size;
+    constructor(peak, size) {
+        this.peak = peak;
+        this.size = size;
+    }
+    static fromPeak(peak, size) {
+        return new Mountain(peak, size);
+    }
+    static fromChildren(hasher, children) {
+        const [left, right] = children;
+        const peak = hasher.hashConcat(left.peak, right.peak);
+        const size = left.size + right.size;
+        return new Mountain(peak, size);
+    }
+    /** Merge with another montain of the same size. */
+    mergeWith(hasher, other) {
+        return Mountain.fromChildren(hasher, [this, other]);
+    }
+    toString() {
+        return `${this.size} @ ${this.peak}`;
+    }
+}

package/packages/core/mmr/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/packages/core/mmr/index.test.d.ts.map

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

package/packages/core/mmr/index.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE, keccak } from "#@typeberry/hash";
+import { MerkleMountainRange } from "./index.js";
+const hasher = keccak.KeccakHasher.create().then((hasher) => {
+    return {
+        hashConcat(a, b) {
+            return keccak.hashBlobs(hasher, [a, b]);
+        },
+        hashConcatPrepend(id, a, b) {
+            return keccak.hashBlobs(hasher, [id, a, b]);
+        },
+    };
+});
+describe("MMR", () => {
+    it("should return empty peaks and zero super hash", async () => {
+        // when
+        const mmr = MerkleMountainRange.empty(await hasher);
+        // then
+        assert.deepEqual(mmr.getPeaks(), { peaks: [] });
+        assert.deepEqual(mmr.getSuperPeakHash().toString(), "0x0000000000000000000000000000000000000000000000000000000000000000");
+    });
+    it("should return one peak and a super hash", async () => {
+        // given
+        const mmr = MerkleMountainRange.empty(await hasher);
+        // when
+        mmr.append(Bytes.parseBytes("0x8720b97ddd6acc0f6eb66e095524038675a4e4067adc10ec39939eaefc47d842", HASH_SIZE));
+        // then
+        assert.deepEqual(strPeaks(mmr.getPeaks()), "[0x8720b97ddd6acc0f6eb66e095524038675a4e4067adc10ec39939eaefc47d842]");
+        assert.deepEqual(mmr.getSuperPeakHash().toString(), "0x8720b97ddd6acc0f6eb66e095524038675a4e4067adc10ec39939eaefc47d842");
+    });
+    it("should return two peaks and a super hash", async () => {
+        // given
+        const mmr = MerkleMountainRange.empty(await hasher);
+        // when
+        mmr.append(Bytes.parseBytes("0x8720b97ddd6acc0f6eb66e095524038675a4e4067adc10ec39939eaefc47d842", HASH_SIZE));
+        mmr.append(Bytes.parseBytes("0x7507515a48439dc58bc318c48a120b656136699f42bfd2bd45473becba53462d", HASH_SIZE));
+        // then
+        assert.deepEqual(strPeaks(mmr.getPeaks()), "[null, 0x7076c31882a5953e097aef8378969945e72807c4705e53a0c5aacc9176f0d56b]");
+        assert.deepEqual(mmr.getSuperPeakHash().toString(), "0x7076c31882a5953e097aef8378969945e72807c4705e53a0c5aacc9176f0d56b");
+    });
+    it("should return more peaks and a super hash", async () => {
+        // given
+        const mmr = MerkleMountainRange.empty(await hasher);
+        // when
+        for (let i = 0; i < 10; i++) {
+            mmr.append(Bytes.parseBytes("0x8720b97ddd6acc0f6eb66e095524038675a4e4067adc10ec39939eaefc47d842", HASH_SIZE));
+            mmr.append(Bytes.parseBytes("0x7507515a48439dc58bc318c48a120b656136699f42bfd2bd45473becba53462d", HASH_SIZE));
+        }
+        // then
+        assert.deepEqual(strPeaks(mmr.getPeaks()), "[null, null, 0x603962acb9fd28fd650da61187a96761a9ca77b79e50278b8befd141ae9912b6, null, 0x0ae801c22b2305f0ce601f9ec42c44c7d63ceb02dc991c84f531e5496e945d98]");
+        assert.deepEqual(mmr.getSuperPeakHash().toString(), "0x1edf0b1f3291a8ffd2d17b8962b5aa58b3f9cf6ec8f9443a81bc786d4c64b7f4");
+    });
+    it("should match reports", async () => {
+        // given
+        const mmr = MerkleMountainRange.fromPeaks(await hasher, {
+            peaks: [
+                "0x4c31a1024d553c6f5eb90a26f9c53507d6d58b7be1197c0f86054b084353de5f",
+                null,
+                "0x7f64e54f8be039cea06582eb38e7f36f924c1f59a0f3043b4df6f140cccd6ddf",
+                "0xd7cc7a7751048dbe8d0232b5d0273acd874e56c19e41a2e09b590ca00e59908d",
+            ].map((x) => (x !== null ? Bytes.parseBytes(x, HASH_SIZE) : x)),
+        });
+        // then
+        assert.deepEqual(mmr.getSuperPeakHash().toString(), "0xf5df0c11416d43c55b43e096572d450b7780ed0fd7b540f26c8ded8e0d41e183");
+    });
+});
+function strPeaks(peaks) {
+    return `[${peaks.peaks.map(String).join(", ")}]`;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Custom base32 encoding used for networking.
+ *
+ * This is not matching the RFC 4648 because of
+ * bit ordering.
+ *
+ * NOTE [ToDr] consider optimizing.
+ */
+export declare function base32(input: Uint8Array): string;
+//# sourceMappingURL=base32.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/base32.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,UAoBvC"}

package/packages/core/networking/base32.js

@@ -0,0 +1,28 @@
+/**
+ * Custom base32 encoding used for networking.
+ *
+ * This is not matching the RFC 4648 because of
+ * bit ordering.
+ *
+ * NOTE [ToDr] consider optimizing.
+ */
+export function base32(input) {
+    function getBit(i) {
+        const byte = i >> 3;
+        const bit = i % 8;
+        const val = input.at(byte) ?? 0;
+        const ret = (val >> bit) & 0x1;
+        return ret;
+    }
+    const res = [];
+    for (let i = 0; i < input.length * 8; i += 5) {
+        let num = 0;
+        for (let j = i + 4; j >= i; j--) {
+            num <<= 1;
+            num |= getBit(j);
+        }
+        res.push(ALPHABET[num]);
+    }
+    return res.join("");
+}
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";

package/packages/core/networking/base32.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=base32.test.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "node:test";
+import { BytesBlob } from "#@typeberry/bytes";
+import { base32 } from "./base32.js";
+describe("base32 encoding", () => {
+    it("should encode to base32", () => {
+        const bytes = BytesBlob.parseBlob("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29");
+        strictEqual(base32(bytes.raw), "3r2oc62zwfj3crnuifuvsxvbtlzetk4o5qyhetkhagsc2fgl2oka");
+    });
+});

package/packages/core/networking/bin/test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test.d.ts.map

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

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

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

@@ -0,0 +1,89 @@
+import { setTimeout } from "node:timers/promises";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { ed25519 } from "#@typeberry/crypto";
+import { Logger } from "#@typeberry/logger";
+import { OK } from "#@typeberry/utils";
+import { Quic } from "../index.js";
+const logger = Logger.new(import.meta.filename, "net:demo");
+async function main(clientPort, serverPort) {
+    const genesisHash = "0259fbe9"; // polkajam: 0259fbe9
+    const clientKey = await ed25519.privateKey(Bytes.fill(ed25519.ED25519_PRIV_KEY_BYTES, 1));
+    const serverKey = await ed25519.privateKey(Bytes.fill(ed25519.ED25519_PRIV_KEY_BYTES, 2));
+    const network = await Quic.setup({
+        host: "127.0.0.1",
+        port: serverPort,
+        key: clientPort === 0 ? serverKey : clientKey,
+        protocols: [`jamnp-s/0/${genesisHash}`],
+    });
+    network.peers.onPeerConnected((peer) => {
+        logger.log `New peer: ${peer.id}`;
+        peer.addOnIncomingStream((stream) => {
+            (async () => {
+                logger.info `🚰  Stream with ${peer.id} opened`;
+                const { readable } = stream;
+                const reader = readable.getReader();
+                for (;;) {
+                    const data = await reader.read();
+                    if (data.value !== undefined) {
+                        const bytes = BytesBlob.blobFrom(data.value);
+                        logger.info `🚰 Peer ${peer.id} stream data: ${bytes}`;
+                    }
+                    if (data.done) {
+                        logger.info `🚰 Peer ${peer.id} stream done.`;
+                        return;
+                    }
+                }
+            })().catch((e) => {
+                logger.error `Error handling stream: ${e}. Disconnecting.`;
+                peer.disconnect();
+            });
+            return OK;
+        });
+        return OK;
+    });
+    await network.start();
+    if (clientPort === 0) {
+        logger.warn `No client port given. Finishing.`;
+        return;
+    }
+    for (;;) {
+        await setTimeout(1000);
+        try {
+            const peer = await network.dial({
+                host: "127.0.0.1",
+                port: clientPort,
+            });
+            logger.log `Connected, opening streams...`;
+            await setTimeout(2000);
+            // open a bunch of streams
+            for (let i = 0; i < 10; i++) {
+                const stream = peer.openStream();
+                // After opening a stream, the stream initiator must send a single byte identifying the stream kind.
+                await stream.writable.getWriter().write(Uint8Array.from([i]));
+            }
+            logger.log `Streams done. Disconnecting.`;
+            await peer.disconnect();
+            break;
+        }
+        catch (e) {
+            logger.warn `Dial error: ${e}`;
+        }
+    }
+    logger.log `Closing networking...`;
+    await network.stop();
+}
+const args = process.argv.slice(2);
+const parsePort = (v) => {
+    if (v === undefined) {
+        return 0;
+    }
+    const p = Number.parseInt(v, 10);
+    if (Number.isNaN(p)) {
+        throw new Error(`Not a number: ${v}`);
+    }
+    return p;
+};
+main(parsePort(args[0]), parsePort(args[1])).catch((e) => {
+    logger.error `${e}`;
+    process.exit(-1);
+});

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

@@ -0,0 +1,45 @@
+import { type JsonWebKey } from "node:crypto";
+import * as x509 from "@peculiar/x509";
+import { BytesBlob } from "#@typeberry/bytes";
+import { type Ed25519Key, type ed25519 } from "#@typeberry/crypto";
+import { Result } from "#@typeberry/utils";
+import type { PeerId } from "./peers.js";
+export declare enum VerifyCertError {
+    NoCertificate = 0,
+    NotEd25519 = 1,
+    PublicKeyTypeMismatch = 2,
+    AltNameMismatch = 3,
+    IncorrectSignature = 4
+}
+export type PeerInfo = {
+    id: PeerId;
+    key: Ed25519Key;
+};
+export declare function verifyCertificate(certs: Uint8Array[]): Promise<Result<PeerInfo, VerifyCertError>>;
+export declare function generateKeyPairEd25519(): Promise<{
+    publicKey: JsonWebKey;
+    privateKey: JsonWebKey;
+}>;
+export declare function privateKeyToPEM(keypair: JsonWebKeyPair): Promise<string>;
+/** Adapted from https://github.com/MatrixAI/js-quic/blob/staging/tests/utils.ts#L388 */
+export declare function generateCertificate({ certId, subjectKeyPair, issuerKeyPair, subjectAttrsExtra, issuerAttrsExtra, now, }: {
+    certId: BytesBlob;
+    subjectKeyPair: JsonWebKeyPair;
+    issuerKeyPair: JsonWebKeyPair;
+    subjectAttrsExtra?: Array<{
+        [key: string]: string[];
+    }>;
+    issuerAttrsExtra?: Array<{
+        [key: string]: string[];
+    }>;
+    now?: Date;
+}): Promise<x509.X509Certificate>;
+export declare function altNameRaw(ed25519PubKey: BytesBlob): string;
+export declare function altNameJwk(ed25519PubKey: JsonWebKey): string;
+export declare function certToPEM(cert: x509.X509Certificate): string;
+export type JsonWebKeyPair = {
+    publicKey: JsonWebKey;
+    privateKey: JsonWebKey;
+};
+export declare function ed25519AsJsonWebKeyPair(keyPair: ed25519.Ed25519Pair): JsonWebKeyPair;
+//# sourceMappingURL=certificate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"certificate.d.ts","sourceRoot":"","sources":["../../../../../packages/core/networking/certificate.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGtD,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAqB,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAErF,OAAO,EAAgB,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAezC,oBAAY,eAAe;IACzB,aAAa,IAAI;IACjB,UAAU,IAAI;IACd,qBAAqB,IAAI;IACzB,eAAe,IAAI;IACnB,kBAAkB,IAAI;CACvB;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,UAAU,CAAC;CACjB,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC,CAwDvG;AAED,wBAAsB,sBAAsB,IAAI,OAAO,CAAC;IACtD,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC,CAcD;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,cAAc,mBAQ5D;AAED,wFAAwF;AACxF,wBAAsB,mBAAmB,CAAC,EACxC,MAAM,EACN,cAAc,EACd,aAAa,EACb,iBAAsB,EACtB,gBAAqB,EACrB,GAAgB,GACjB,EAAE;IACD,MAAM,EAAE,SAAS,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,cAAc,CAAC;IAC9B,iBAAiB,CAAC,EAAE,KAAK,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACvD,gBAAgB,CAAC,EAAE,KAAK,CAAC;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACtD,GAAG,CAAC,EAAE,IAAI,CAAC;CACZ,GAAG,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CA6EhC;AAED,wBAAgB,UAAU,CAAC,aAAa,EAAE,SAAS,UAElD;AACD,wBAAgB,UAAU,CAAC,aAAa,EAAE,UAAU,UAGnD;AA4BD,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,eAAe,UAEnD;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;CACxB,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,GAAG,cAAc,CAkBpF"}

package/packages/core/networking/certificate.js

@@ -0,0 +1,198 @@
+import crypto from "node:crypto";
+import * as peculiarWebcrypto from "@peculiar/webcrypto";
+import * as x509 from "@peculiar/x509";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { ED25519_KEY_BYTES } from "#@typeberry/crypto";
+import { Logger } from "#@typeberry/logger";
+import { asOpaqueType, Result } from "#@typeberry/utils";
+import { base32 } from "./base32.js";
+const logger = Logger.new(import.meta.filename, "net");
+// TODO [ToDr] Might not be relevant any more and we can use built-in webcrypto.
+// overwrite crypto provider to use the @peculiar version
+// (ed25519 issues in the node one, see:
+// https://github.com/MatrixAI/js-quic/blob/staging/tests/utils.ts#L16C9-L16C64
+// )
+const webcrypto = new peculiarWebcrypto.Crypto();
+x509.cryptoProvider.set(webcrypto);
+const CURVE_NAME = "Ed25519";
+const KEY_TYPE = "OKP"; // Offline Key Pair
+export var VerifyCertError;
+(function (VerifyCertError) {
+    VerifyCertError[VerifyCertError["NoCertificate"] = 0] = "NoCertificate";
+    VerifyCertError[VerifyCertError["NotEd25519"] = 1] = "NotEd25519";
+    VerifyCertError[VerifyCertError["PublicKeyTypeMismatch"] = 2] = "PublicKeyTypeMismatch";
+    VerifyCertError[VerifyCertError["AltNameMismatch"] = 3] = "AltNameMismatch";
+    VerifyCertError[VerifyCertError["IncorrectSignature"] = 4] = "IncorrectSignature";
+})(VerifyCertError || (VerifyCertError = {}));
+export async function verifyCertificate(certs) {
+    logger.log `Incoming peer. Verifying certificate`;
+    // Must present exactly one cert
+    if (certs.length !== 1) {
+        logger.log `Rejecting peer: expected exactly one certificate, got: ${certs.length}`;
+        return Result.error(VerifyCertError.NoCertificate, () => `Certificate validation failed: expected exactly one certificate, got ${certs.length}`);
+    }
+    // Parse with Node's X509Certificate (accepts PEM or DER)
+    const xc = new crypto.X509Certificate(certs[0]);
+    // Must be Ed25519 key
+    if (xc.publicKey.asymmetricKeyType !== CURVE_NAME.toLowerCase()) {
+        logger.log `Rejecting peer using non-ed25519 certificate: ${xc.publicKey.asymmetricKeyType}`;
+        return Result.error(VerifyCertError.NotEd25519, () => `Certificate validation failed: expected Ed25519 key, got ${xc.publicKey.asymmetricKeyType}`);
+    }
+    // Extract raw public key via JWK export
+    const jwk = xc.publicKey.export({ format: "jwk" });
+    if (jwk.kty !== KEY_TYPE || jwk.crv !== CURVE_NAME) {
+        logger.log `Public key type mismatch: ${jwk.kty}, ${jwk.crv}`;
+        return Result.error(VerifyCertError.PublicKeyTypeMismatch, () => `Certificate validation failed: public key type mismatch (kty: ${jwk.kty}, crv: ${jwk.crv})`);
+    }
+    // SAN must be exactly 'e'+base32(rawPub)
+    const expectedSan = altNameJwk(jwk);
+    const sanField = xc.subjectAltName ?? "";
+    const m = sanField.match(/DNS:([^,]+)/);
+    if (m === null || m[1] !== expectedSan) {
+        logger.log `AltName mismatch. Expected: '${expectedSan}', got: '${m?.[1]}'`;
+        return Result.error(VerifyCertError.AltNameMismatch, () => `Certificate validation failed: altName mismatch (expected: ${expectedSan}, got: ${m?.[1] ?? "none"})`);
+    }
+    const key = Buffer.from(jwk.x ?? "", "base64url");
+    if (!xc.verify(xc.publicKey)) {
+        return Result.error(VerifyCertError.IncorrectSignature, () => "Certificate validation failed: incorrect signature");
+    }
+    const publicKey = Bytes.fromBlob(new Uint8Array(key), ED25519_KEY_BYTES);
+    return Result.ok({
+        id: asOpaqueType(expectedSan),
+        key: publicKey.asOpaque(),
+    });
+}
+export async function generateKeyPairEd25519() {
+    const keyPair = await webcrypto.subtle.generateKey({
+        name: "EdDSA",
+        namedCurve: "Ed25519",
+    }, true, ["sign", "verify"]);
+    return {
+        publicKey: await webcrypto.subtle.exportKey("jwk", keyPair.publicKey),
+        privateKey: await webcrypto.subtle.exportKey("jwk", keyPair.privateKey),
+    };
+}
+export async function privateKeyToPEM(keypair) {
+    const key = await importEd25519Key(keypair.privateKey, KeyType.Private);
+    // Export as PKCS8
+    const exported = await webcrypto.subtle.exportKey("pkcs8", key);
+    // Base64-encode and wrap as PEM
+    const b64 = Buffer.from(exported).toString("base64");
+    const lines = b64.match(/.{1,64}/g) ?? [];
+    return ["-----BEGIN PRIVATE KEY-----", ...lines, "-----END PRIVATE KEY-----", ""].join("\n");
+}
+/** Adapted from https://github.com/MatrixAI/js-quic/blob/staging/tests/utils.ts#L388 */
+export async function generateCertificate({ certId, subjectKeyPair, issuerKeyPair, subjectAttrsExtra = [], issuerAttrsExtra = [], now = new Date(), }) {
+    const subjectPublicCryptoKey = await importEd25519Key(subjectKeyPair.publicKey, KeyType.Public);
+    const subjectPrivateCryptoKey = await importEd25519Key(subjectKeyPair.privateKey, KeyType.Private);
+    const issuerPrivateCryptoKey = await importEd25519Key(issuerKeyPair.privateKey, KeyType.Private);
+    const issuerPublicCryptoKey = await importEd25519Key(issuerKeyPair.publicKey, KeyType.Public);
+    // X509 `UTCTime` format only has resolution of seconds
+    // this truncates to second resolution
+    const notBeforeDate = new Date(now.getTime() - (now.getTime() % 1000));
+    const durationSeconds = 2;
+    const notAfterDate = new Date(now.getTime() - (now.getTime() % 1000) + durationSeconds * 1000);
+    const subjectNodeId = await webcrypto.subtle.digest("SHA-256", await webcrypto.subtle.exportKey("spki", subjectPublicCryptoKey));
+    const issuerNodeId = await webcrypto.subtle.digest("SHA-256", await webcrypto.subtle.exportKey("spki", issuerPublicCryptoKey));
+    const serialNumber = certId.toString().substring(2);
+    const subjectNodeIdEncoded = Buffer.from(subjectNodeId).toString("hex");
+    const issuerNodeIdEncoded = Buffer.from(issuerNodeId).toString("hex");
+    // The entire subject attributes and issuer attributes
+    // is constructed via `x509.Name` class
+    // By default this supports on a limited set of names:
+    // CN, L, ST, O, OU, C, DC, E, G, I, SN, T
+    // If custom names are desired, this needs to change to constructing
+    // `new x509.Name('FOO=BAR', { FOO: '1.2.3.4' })` manually
+    // And each custom attribute requires a registered OID
+    // Because the OID is what is encoded into ASN.1
+    const subjectAttrs = [
+        {
+            CN: [subjectNodeIdEncoded],
+        },
+        // Filter out conflicting CN attributes
+        ...subjectAttrsExtra.filter((attr) => !("CN" in attr)),
+    ];
+    const issuerAttrs = [
+        {
+            CN: [issuerNodeIdEncoded],
+        },
+        // Filter out conflicting CN attributes
+        ...issuerAttrsExtra.filter((attr) => !("CN" in attr)),
+    ];
+    const certConfig = {
+        serialNumber,
+        notBefore: notBeforeDate,
+        notAfter: notAfterDate,
+        subject: subjectAttrs,
+        issuer: issuerAttrs,
+        signingAlgorithm: issuerPrivateCryptoKey.algorithm,
+        publicKey: subjectPublicCryptoKey,
+        signingKey: subjectPrivateCryptoKey,
+        extensions: [
+            new x509.BasicConstraintsExtension(true),
+            new x509.KeyUsagesExtension(x509.KeyUsageFlags.keyCertSign |
+                x509.KeyUsageFlags.cRLSign |
+                x509.KeyUsageFlags.digitalSignature |
+                x509.KeyUsageFlags.nonRepudiation |
+                x509.KeyUsageFlags.keyAgreement |
+                x509.KeyUsageFlags.keyEncipherment |
+                x509.KeyUsageFlags.dataEncipherment),
+            new x509.ExtendedKeyUsageExtension([]),
+            new x509.SubjectAlternativeNameExtension([
+                {
+                    type: "dns",
+                    value: altNameJwk(subjectKeyPair.publicKey),
+                },
+            ]),
+            await x509.SubjectKeyIdentifierExtension.create(subjectPublicCryptoKey),
+        ],
+    };
+    certConfig.signingKey = issuerPrivateCryptoKey;
+    return await x509.X509CertificateGenerator.create(certConfig);
+}
+export function altNameRaw(ed25519PubKey) {
+    return `e${base32(ed25519PubKey.raw)}`;
+}
+export function altNameJwk(ed25519PubKey) {
+    const rawPub = new Uint8Array(Buffer.from(ed25519PubKey.x ?? "", "base64url"));
+    return altNameRaw(BytesBlob.blobFrom(rawPub));
+}
+var KeyType;
+(function (KeyType) {
+    /** Used only to verify signatures. */
+    KeyType[KeyType["Public"] = 0] = "Public";
+    /** Used only to sign. */
+    KeyType[KeyType["Private"] = 1] = "Private";
+})(KeyType || (KeyType = {}));
+async function importEd25519Key(key, typ) {
+    if (key.kty !== KEY_TYPE) {
+        throw new Error(`Unsupported key type ${key.kty}`);
+    }
+    const algorithm = {
+        name: "EdDSA",
+        namedCurve: CURVE_NAME,
+    };
+    /** https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey */
+    return await webcrypto.subtle.importKey("jwk", key, algorithm, true /* Can the key be extracted using `exportKey`? */, [typ === KeyType.Public ? "verify" : "sign"]);
+}
+export function certToPEM(cert) {
+    return `${cert.toString("pem")}\n`;
+}
+export function ed25519AsJsonWebKeyPair(keyPair) {
+    const key = {
+        kty: KEY_TYPE,
+        crv: CURVE_NAME,
+        x: Buffer.from(keyPair.pubKey.raw).toString("base64url"),
+        d: Buffer.from(keyPair._privKey.raw).toString("base64url"),
+    };
+    return {
+        publicKey: {
+            ...key,
+            d: undefined,
+        },
+        privateKey: {
+            ...key,
+            x: undefined,
+        },
+    };
+}

package/packages/core/networking/certificate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=certificate.test.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { describe, it } from "node:test";
+import * as x509 from "@peculiar/x509";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { ed25519 } from "#@typeberry/crypto";
+import { altNameJwk, ed25519AsJsonWebKeyPair, generateCertificate, VerifyCertError, verifyCertificate, } from "./certificate.js";
+// taken from jamcha.in
+// currently invalid, due to altname encoding mismatch.
+const ALICE_CERT = fs
+    .readFileSync(path.resolve(`${import.meta.dirname}/fixtures/alice-imported.cert.pem`), "utf8")
+    .trim();
+const BOB_CERT = fs.readFileSync(path.resolve(`${import.meta.dirname}/fixtures/bob-generated.cert.pem`), "utf8").trim();
+const ALICE_PAIR = ed25519.privateKey(Bytes.fill(ed25519.ED25519_PRIV_KEY_BYTES, 0).asOpaque());
+const BOB_PAIR = ed25519.privateKey(Bytes.fill(ed25519.ED25519_PRIV_KEY_BYTES, 1).asOpaque());
+describe("altName", () => {
+    it("should compute Alices alt name", async () => {
+        const alice = await ALICE_PAIR;
+        const keyPair = ed25519AsJsonWebKeyPair(alice);
+        const aliceAltName = altNameJwk(keyPair.publicKey);
+        assert.strictEqual(aliceAltName, "e3r2oc62zwfj3crnuifuvsxvbtlzetk4o5qyhetkhagsc2fgl2oka");
+    });
+});
+describe("X509 Certificate", () => {
+    it("should generate cert", async () => {
+        const ed25519Pair = await BOB_PAIR;
+        const keyPair = ed25519AsJsonWebKeyPair(ed25519Pair);
+        const cert = await generateCertificate({
+            certId: BytesBlob.blobFromString("QUIC Networking"),
+            subjectKeyPair: keyPair,
+            issuerKeyPair: keyPair,
+            now: new Date(Date.UTC(2025, 4, 30, 9, 0, 0, 0)),
+        });
+        const altName = cert.getExtension(x509.SubjectAlternativeNameExtension);
+        // make sure the alternative name is correct
+        assert.strictEqual(altName?.toString(), "Subject Alternative Name:\n" + "  DNS: ekech6otoji4lz6lk3olyd5wlstspwe4x5affrnm6udcda26bpdxa");
+        // check the whole certificate
+        assert.deepStrictEqual(cert.toString(), BOB_CERT);
+    });
+    it("should validate certificate generated by openssl", async () => {
+        const cert = new x509.X509Certificate(ALICE_CERT);
+        const certDer = new Uint8Array(cert.rawData);
+        // const alicePair = await ALICE_PAIR;
+        // when
+        const verificationResult = await verifyCertificate([certDer]);
+        // then
+        assert.deepEqual(verificationResult.isError && verificationResult.error, VerifyCertError.AltNameMismatch);
+    });
+});