@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/concurrent/parent.js

@@ -0,0 +1,142 @@
+import { Worker } from "node:worker_threads";
+import { check } from "#@typeberry/utils";
+// Amount of tasks in the queue that will trigger creation of new worker thread.
+// NOTE this might need to be configurable in the future.
+const QUEUE_SIZE_WORKER_THRESHOLD = 5;
+/** Execution pool manager. */
+export class Executor {
+    workers;
+    maxWorkers;
+    workerPath;
+    /** Initialize a new concurrent executor given a path to the worker. */
+    static async initialize(workerPath, options) {
+        check `${options.maxWorkers > 0} Max workers has to be positive.`;
+        check `${options.minWorkers <= options.maxWorkers} Min workers must be less than or equal to max workers (min=${options.minWorkers}, max=${options.maxWorkers}).`;
+        const workers = [];
+        for (let i = 0; i < options.minWorkers; i++) {
+            workers.push(await initWorker(workerPath));
+        }
+        return new Executor(workers, options.maxWorkers, workerPath);
+    }
+    // keeps track of the indices of worker threads that are currently free and available to execute tasks
+    freeWorkerIndices = [];
+    taskQueue = [];
+    isDestroyed = false;
+    isWorkerInitializing = false;
+    constructor(workers, maxWorkers, workerPath) {
+        this.workers = workers;
+        this.maxWorkers = maxWorkers;
+        this.workerPath = workerPath;
+        // intial free workers.
+        for (let i = 0; i < workers.length; i++) {
+            this.freeWorkerIndices.push(i);
+        }
+    }
+    /** Attempt to initialize a new worker. */
+    async initNewWorker(onSuccess = () => { }) {
+        if (this.workers.length >= this.maxWorkers) {
+            // biome-ignore lint/suspicious/noConsole: warning
+            console.warn(`Task queue has ${this.taskQueue.length} pending items and we can't init any more workers.`);
+            return;
+        }
+        if (this.isWorkerInitializing) {
+            return;
+        }
+        this.isWorkerInitializing = true;
+        this.workers.push(await initWorker(this.workerPath));
+        this.freeWorkerIndices.push(this.workers.length - 1);
+        this.isWorkerInitializing = false;
+        onSuccess();
+    }
+    /** Terminate all workers and clear the executor. */
+    async destroy() {
+        for (const worker of this.workers) {
+            worker.port.close();
+            await worker.worker.terminate();
+        }
+        this.workers.length = 0;
+        this.isDestroyed = true;
+    }
+    /** Execute a task with given parameters. */
+    async run(params) {
+        return new Promise((resolve, reject) => {
+            if (this.isDestroyed) {
+                reject("pool destroyed");
+                return;
+            }
+            this.taskQueue.push({
+                params,
+                resolve,
+                reject,
+            });
+            this.processEntryFromTaskQueue();
+        });
+    }
+    /** Process single element from the task queue. */
+    processEntryFromTaskQueue() {
+        const freeWorker = this.freeWorkerIndices.pop();
+        // no free workers available currently,
+        // we will retry when one of the tasks completes.
+        if (freeWorker === undefined) {
+            if (this.taskQueue.length > QUEUE_SIZE_WORKER_THRESHOLD) {
+                this.initNewWorker(() => {
+                    // process an entry in this newly initialized worker.
+                    this.processEntryFromTaskQueue();
+                });
+            }
+            return;
+        }
+        const task = this.taskQueue.pop();
+        // no tasks in the queue
+        if (task === undefined) {
+            this.freeWorkerIndices.push(freeWorker);
+            return;
+        }
+        const worker = this.workers[freeWorker];
+        worker.runTask(task, () => {
+            // mark the worker as available again
+            this.freeWorkerIndices.push(freeWorker);
+            // and continue processing the queue
+            this.processEntryFromTaskQueue();
+        });
+    }
+}
+async function initWorker(workerPath) {
+    // create a worker and initialize communication channel
+    const { port1, port2 } = new MessageChannel();
+    const workerThread = new Worker(workerPath, {});
+    workerThread.postMessage(port1, [port1]);
+    // // wait for the worker to start
+    await new Promise((resolve, reject) => {
+        workerThread.once("message", resolve);
+        workerThread.once("error", reject);
+    });
+    // make sure the threads don't prevent the program from stopping.
+    workerThread.unref();
+    return new WorkerChannel(workerThread, port2);
+}
+class WorkerChannel {
+    worker;
+    port;
+    constructor(worker, port) {
+        this.worker = worker;
+        this.port = port;
+    }
+    runTask(task, onFinish) {
+        const message = {
+            params: task.params,
+        };
+        // when we receive a response, make sure to process it
+        this.port.once("message", (e) => {
+            if (e.isOk) {
+                task.resolve(e.ok);
+            }
+            else {
+                task.reject(new Error(e.error));
+            }
+            onFinish();
+        });
+        // send the task to work on.
+        this.port.postMessage(message, message.params.getTransferList());
+    }
+}

package/packages/core/concurrent/worker.d.ts

@@ -0,0 +1,13 @@
+import type { IExecutor, WithTransferList } from "./messages.js";
+/** A in-worker abstraction. */
+export declare class ConcurrentWorker<TParams, TResult extends WithTransferList, TInternalState> implements IExecutor<TParams, TResult> {
+    private readonly runInternal;
+    readonly state: TInternalState;
+    static new<XParams, XResult extends WithTransferList, XInternalState>(run: (params: XParams, state: XInternalState) => Promise<XResult>, state: XInternalState): ConcurrentWorker<XParams, XResult, XInternalState>;
+    private constructor();
+    listenToParentPort(): void;
+    private listenTo;
+    run(params: TParams): Promise<TResult>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=worker.d.ts.map

package/packages/core/concurrent/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../../../packages/core/concurrent/worker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAyB,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAExF,+BAA+B;AAC/B,qBAAa,gBAAgB,CAAC,OAAO,EAAE,OAAO,SAAS,gBAAgB,EAAE,cAAc,CACrF,YAAW,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAUpC,OAAO,CAAC,QAAQ,CAAC,WAAW;aACZ,KAAK,EAAE,cAAc;IATvC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,SAAS,gBAAgB,EAAE,cAAc,EAClE,GAAG,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,EACjE,KAAK,EAAE,cAAc;IAKvB,OAAO;IAKP,kBAAkB;IAclB,OAAO,CAAC,QAAQ;IAoBV,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAItC,OAAO;CACd"}

package/packages/core/concurrent/worker.js

@@ -0,0 +1,49 @@
+import { parentPort } from "node:worker_threads";
+import { Result } from "#@typeberry/utils";
+/** A in-worker abstraction. */
+export class ConcurrentWorker {
+    runInternal;
+    state;
+    static new(run, state) {
+        return new ConcurrentWorker(run, state);
+    }
+    constructor(runInternal, state) {
+        this.runInternal = runInternal;
+        this.state = state;
+    }
+    listenToParentPort() {
+        if (parentPort === null) {
+            throw new Error("This method is meant to be run inside a worker thread!");
+        }
+        parentPort.once("close", () => {
+            process.exit(0);
+        });
+        parentPort.once("message", (port) => {
+            this.listenTo(port);
+            // send back readiness signal.
+            parentPort?.postMessage("ready");
+        });
+    }
+    listenTo(port) {
+        port.once("close", () => {
+            port.removeAllListeners();
+            process.exit(0);
+        });
+        port.on("message", (ev) => {
+            const { params } = ev;
+            this.run(params)
+                .then((result) => {
+                const response = Result.ok(result);
+                port.postMessage(response, result.getTransferList());
+            })
+                .catch((e) => {
+                const response = Result.error(`${e}`, () => `Worker execution failed: ${e}`);
+                port.postMessage(response, []);
+            });
+        });
+    }
+    async run(params) {
+        return await this.runInternal(params, this.state);
+    }
+    async destroy() { }
+}

package/packages/core/crypto/bandersnatch.d.ts

@@ -0,0 +1,50 @@
+import { Bytes } from "#@typeberry/bytes";
+import { type Opaque } from "#@typeberry/utils";
+/** Bandersnatch public key size. */
+export declare const BANDERSNATCH_KEY_BYTES = 32;
+export type BANDERSNATCH_KEY_BYTES = typeof BANDERSNATCH_KEY_BYTES;
+/** Bandersnatch VRF signature size */
+export declare const BANDERSNATCH_VRF_SIGNATURE_BYTES = 96;
+export type BANDERSNATCH_VRF_SIGNATURE_BYTES = typeof BANDERSNATCH_VRF_SIGNATURE_BYTES;
+/** Bandersnatch ring commitment size */
+export declare const BANDERSNATCH_RING_ROOT_BYTES = 144;
+export type BANDERSNATCH_RING_ROOT_BYTES = typeof BANDERSNATCH_RING_ROOT_BYTES;
+/** Bandersnatch proof size */
+export declare const BANDERSNATCH_PROOF_BYTES = 784;
+export type BANDERSNATCH_PROOF_BYTES = typeof BANDERSNATCH_PROOF_BYTES;
+/** BLS public key size. */
+export declare const BLS_KEY_BYTES = 144;
+export type BLS_KEY_BYTES = typeof BLS_KEY_BYTES;
+/**
+ * Potentially valid Bandersnatch public key.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/082200082200?v=0.6.7
+ */
+export type BandersnatchKey = Opaque<Bytes<BANDERSNATCH_KEY_BYTES>, "BandersnatchKey">;
+/**
+ * Bandersnatch ring commitment
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0da8000dc200?v=0.6.7
+ */
+export type BandersnatchRingRoot = Opaque<Bytes<BANDERSNATCH_RING_ROOT_BYTES>, "BandersnatchRingRoot">;
+/**
+ * Potentially valid Bandersnatch signature.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/082300082300?v=0.6.7
+ */
+export type BandersnatchVrfSignature = Opaque<Bytes<BANDERSNATCH_VRF_SIGNATURE_BYTES>, "BandersnatchVrfSignature">;
+/**
+ * Potentially valid Bandersnatch RingVRF proof of knowledge.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/082d00083a00?v=0.6.7
+ */
+export type BandersnatchProof = Opaque<Bytes<BANDERSNATCH_PROOF_BYTES>, "BandersnatchRingSignature">;
+/**
+ * A public key for BLS signature scheme
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/081c00081c00?v=0.6.7
+ */
+export type BlsKey = Opaque<Bytes<BLS_KEY_BYTES>, "BlsKey">;
+/** Derive a Bandersnatch public key from a seed. */
+export declare function publicKey(seed: Uint8Array): BandersnatchKey;
+//# sourceMappingURL=bandersnatch.d.ts.map

package/packages/core/crypto/bandersnatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bandersnatch.d.ts","sourceRoot":"","sources":["../../../../../packages/core/crypto/bandersnatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEtD,oCAAoC;AACpC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC;AAEnE,sCAAsC;AACtC,eAAO,MAAM,gCAAgC,KAAK,CAAC;AACnD,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAC;AAEvF,wCAAwC;AACxC,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,MAAM,MAAM,4BAA4B,GAAG,OAAO,4BAA4B,CAAC;AAE/E,8BAA8B;AAC9B,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC;AAEvE,2BAA2B;AAC3B,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,sBAAsB,CAAC,EAAE,iBAAiB,CAAC,CAAC;AAEvF;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,EAAE,sBAAsB,CAAC,CAAC;AAEvG;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,KAAK,CAAC,gCAAgC,CAAC,EAAE,0BAA0B,CAAC,CAAC;AAEnH;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,KAAK,CAAC,wBAAwB,CAAC,EAAE,2BAA2B,CAAC,CAAC;AAErG;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;AAE5D,oDAAoD;AACpD,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,eAAe,CAM3D"}

package/packages/core/crypto/bandersnatch.js

@@ -0,0 +1,19 @@
+import { Bytes } from "#@typeberry/bytes";
+import { bandersnatch } from "@typeberry/native";
+import { check } from "#@typeberry/utils";
+/** Bandersnatch public key size. */
+export const BANDERSNATCH_KEY_BYTES = 32;
+/** Bandersnatch VRF signature size */
+export const BANDERSNATCH_VRF_SIGNATURE_BYTES = 96;
+/** Bandersnatch ring commitment size */
+export const BANDERSNATCH_RING_ROOT_BYTES = 144;
+/** Bandersnatch proof size */
+export const BANDERSNATCH_PROOF_BYTES = 784;
+/** BLS public key size. */
+export const BLS_KEY_BYTES = 144;
+/** Derive a Bandersnatch public key from a seed. */
+export function publicKey(seed) {
+    const key = bandersnatch.derive_public_key(seed);
+    check `${key[0] === 0} Invalid Bandersnatch public key derived from seed`;
+    return Bytes.fromBlob(key.subarray(1), BANDERSNATCH_KEY_BYTES).asOpaque();
+}

package/packages/core/crypto/bandersnatch.test.d.ts

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

package/packages/core/crypto/bandersnatch.test.d.ts.map

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

package/packages/core/crypto/bandersnatch.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { initWasm } from "./index.js";
+import { deriveBandersnatchPublicKey, SEED_SIZE } from "./key-derivation.js";
+before(initWasm);
+describe("BandersnatchKey Derivation", () => {
+    it("should derive a valid Bandersnatch public key from a secret seed", () => {
+        const seed = Bytes.fromBlob(Bytes.parseBlobNoPrefix("007596986419e027e65499cc87027a236bf4a78b5e8bd7f675759d73e7a9c799").raw, SEED_SIZE).asOpaque();
+        const publicKey = deriveBandersnatchPublicKey(seed);
+        const expected = Bytes.fromBlob(Bytes.parseBlobNoPrefix("ff71c6c03ff88adb5ed52c9681de1629a54e702fc14729f6b50d2f0a76f185b3").raw, SEED_SIZE).asOpaque();
+        assert.deepEqual(publicKey, expected);
+    });
+});

package/packages/core/crypto/ed25519.d.ts

@@ -0,0 +1,67 @@
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { type Opaque } from "#@typeberry/utils";
+/** ED25519 private key size. */
+export declare const ED25519_PRIV_KEY_BYTES = 32;
+type ED25519_PRIV_KEY_BYTES = typeof ED25519_PRIV_KEY_BYTES;
+/** ED25519 public key size. */
+export declare const ED25519_KEY_BYTES = 32;
+export type ED25519_KEY_BYTES = typeof ED25519_KEY_BYTES;
+/** ED25519 signature size. */
+export declare const ED25519_SIGNATURE_BYTES = 64;
+export type ED25519_SIGNATURE_BYTES = typeof ED25519_SIGNATURE_BYTES;
+/**
+ * Potentially valid Ed25519 public key.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/081300081a00
+ */
+export type Ed25519Key = Opaque<Bytes<ED25519_KEY_BYTES>, "Ed25519Key">;
+/**
+ * Potentially valid Ed25519 signature.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/081300081a00
+ */
+export type Ed25519Signature = Opaque<Bytes<ED25519_SIGNATURE_BYTES>, "Ed25519Signature">;
+/**
+ * Ed25519 pub+priv key pair.
+ *
+ * Can be passed to `sign` method to produce signatures.
+ */
+export declare class Ed25519Pair {
+    /** Public key */
+    readonly pubKey: Ed25519Key;
+    /** Private key. NOTE: Avoid using directly. */
+    readonly _privKey: Bytes<ED25519_PRIV_KEY_BYTES>;
+    constructor(
+    /** Public key */
+    pubKey: Ed25519Key, 
+    /** Private key. NOTE: Avoid using directly. */
+    _privKey: Bytes<ED25519_PRIV_KEY_BYTES>);
+}
+/** Create a private key from given raw bytes. */
+export declare function privateKey(privKey: Bytes<ED25519_PRIV_KEY_BYTES>): Promise<Ed25519Pair>;
+/** Sign given piece of data using provided key pair. */
+export declare function sign<T extends BytesBlob>(key: Ed25519Pair, message: T): Promise<Ed25519Signature>;
+/** Signature verification input. */
+export type Input<T extends BytesBlob = BytesBlob> = {
+    /** Signature. */
+    signature: Ed25519Signature;
+    /** Public key. */
+    key: Ed25519Key;
+    /** Message to verify. */
+    message: T;
+};
+/**
+ * Verify the entire batch of `ed25519` signatures and return the results.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/081300081b00
+ */
+export declare function verify<T extends BytesBlob>(input: Input<T>[]): Promise<boolean[]>;
+/**
+ * Verify the entire batch of `ed25519` signatures and return the results.
+ *
+ * This function is faster than `verify` but it is not safe.
+ * See "Batch verification" at the bottom here: https://crates.io/crates/ed25519-dalek
+ */
+export declare function verifyBatch<T extends BytesBlob>(input: Input<T>[]): Promise<boolean>;
+export {};
+//# sourceMappingURL=ed25519.d.ts.map

package/packages/core/crypto/ed25519.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519.d.ts","sourceRoot":"","sources":["../../../../../packages/core/crypto/ed25519.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAS,KAAK,MAAM,EAAuB,MAAM,kBAAkB,CAAC;AAE3E,gCAAgC;AAChC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,KAAK,sBAAsB,GAAG,OAAO,sBAAsB,CAAC;AAE5D,+BAA+B;AAC/B,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AAEzD,8BAA8B;AAC9B,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,YAAY,CAAC,CAAC;AAExE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,kBAAkB,CAAC,CAAC;AAE1F;;;;GAIG;AACH,qBAAa,WAAW;IAEpB,iBAAiB;aACD,MAAM,EAAE,UAAU;IAClC,+CAA+C;aAC/B,QAAQ,EAAE,KAAK,CAAC,sBAAsB,CAAC;;IAHvD,iBAAiB;IACD,MAAM,EAAE,UAAU;IAClC,+CAA+C;IAC/B,QAAQ,EAAE,KAAK,CAAC,sBAAsB,CAAC;CAE1D;AAED,iDAAiD;AACjD,wBAAsB,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,sBAAsB,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAG7F;AAED,wDAAwD;AACxD,wBAAsB,IAAI,CAAC,CAAC,SAAS,SAAS,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGvG;AAED,oCAAoC;AACpC,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI;IACnD,iBAAiB;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,kBAAkB;IAClB,GAAG,EAAE,UAAU,CAAC;IAChB,yBAAyB;IACzB,OAAO,EAAE,CAAC,CAAC;CACZ,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CA2BvF;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAa1F"}

package/packages/core/crypto/ed25519.js

@@ -0,0 +1,81 @@
+import * as ed from "@noble/ed25519";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { ed25519 } from "@typeberry/native";
+import { check, safeAllocUint8Array } from "#@typeberry/utils";
+/** ED25519 private key size. */
+export const ED25519_PRIV_KEY_BYTES = 32;
+/** ED25519 public key size. */
+export const ED25519_KEY_BYTES = 32;
+/** ED25519 signature size. */
+export const ED25519_SIGNATURE_BYTES = 64;
+/**
+ * Ed25519 pub+priv key pair.
+ *
+ * Can be passed to `sign` method to produce signatures.
+ */
+export class Ed25519Pair {
+    pubKey;
+    _privKey;
+    constructor(
+    /** Public key */
+    pubKey, 
+    /** Private key. NOTE: Avoid using directly. */
+    _privKey) {
+        this.pubKey = pubKey;
+        this._privKey = _privKey;
+    }
+}
+/** Create a private key from given raw bytes. */
+export async function privateKey(privKey) {
+    const pubKey = await ed.getPublicKeyAsync(privKey.raw);
+    return new Ed25519Pair(Bytes.fromBlob(pubKey, ED25519_KEY_BYTES).asOpaque(), privKey.asOpaque());
+}
+/** Sign given piece of data using provided key pair. */
+export async function sign(key, message) {
+    const signature = await ed.signAsync(message.raw, key._privKey.raw);
+    return Bytes.fromBlob(signature, ED25519_SIGNATURE_BYTES).asOpaque();
+}
+/**
+ * Verify the entire batch of `ed25519` signatures and return the results.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/081300081b00
+ */
+export async function verify(input) {
+    if (input.length === 0) {
+        return Promise.resolve([]);
+    }
+    const dataLength = input.reduce((acc, { message, key, signature }) => acc + key.length + signature.length + message.length + 1, 0);
+    const data = safeAllocUint8Array(dataLength);
+    let offset = 0;
+    for (const { key, message, signature } of input) {
+        data.set(key.raw, offset);
+        offset += ED25519_KEY_BYTES;
+        data.set(signature.raw, offset);
+        offset += ED25519_SIGNATURE_BYTES;
+        const messageLength = message.length;
+        check `${messageLength < 256} Message needs to be shorter than 256 bytes. Got: ${messageLength}`;
+        data[offset] = messageLength;
+        offset += 1;
+        data.set(message.raw, offset);
+        offset += messageLength;
+    }
+    const result = Array.from(ed25519.verify_ed25519(data)).map((x) => x === 1);
+    return Promise.resolve(result);
+}
+/**
+ * Verify the entire batch of `ed25519` signatures and return the results.
+ *
+ * This function is faster than `verify` but it is not safe.
+ * See "Batch verification" at the bottom here: https://crates.io/crates/ed25519-dalek
+ */
+export async function verifyBatch(input) {
+    if (input.length === 0) {
+        return true;
+    }
+    const [first, ...rest] = input.map(({ key, signature, message }) => {
+        const messageLength = message.raw.length;
+        return BytesBlob.blobFromParts(key.raw, signature.raw, Uint8Array.from([messageLength]), message.raw).raw;
+    });
+    const data = BytesBlob.blobFromParts(first, ...rest).raw;
+    return Promise.resolve(ed25519.verify_ed25519_batch(data));
+}

package/packages/core/crypto/ed25519.test.d.ts

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

package/packages/core/crypto/ed25519.test.d.ts.map

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

package/packages/core/crypto/ed25519.test.js

@@ -0,0 +1,59 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { asOpaqueType } from "#@typeberry/utils";
+import { ED25519_KEY_BYTES, ED25519_SIGNATURE_BYTES } from "./ed25519.js";
+import { ed25519, initWasm } from "./index.js";
+before(initWasm);
+describe("crypto.ed25519", () => {
+    it("should produce a signature and verify it", async () => {
+        const key = await ed25519.privateKey(Bytes.zero(ed25519.ED25519_PRIV_KEY_BYTES));
+        const message = Bytes.blobFromString("Hello world!");
+        const signature = await ed25519.sign(key, message);
+        assert.strictEqual(signature.toString(), "0x99a3ca1ebdaed52cce90360a5ed42b17a3d2b9a7a00d54b3d1c86dd515063fc48c339bbbd890a3c5373d9a16651da6de8e63cbf6034db417cc3e3538737e500e");
+        const result = await ed25519.verify([
+            {
+                signature,
+                key: key.pubKey,
+                message,
+            },
+        ]);
+        assert.deepStrictEqual(result, [true]);
+    });
+    it("should verify a bunch of signatures using verify", async () => {
+        const results = await ed25519.verify(VALID_EXAMPLES.concat({
+            ...VALID_EXAMPLES[0],
+            message: BytesBlob.blobFromString("hello world"),
+        }));
+        assert.deepStrictEqual(results, [true, true, false]);
+    });
+    it("should verify a bunch of signatures using verifyBatch and return true", async () => {
+        const results = await ed25519.verifyBatch(VALID_EXAMPLES);
+        assert.strictEqual(results, true);
+    });
+    it("should verify a bunch of signatures using verifyBatch and return false", async () => {
+        const results = await ed25519.verifyBatch(VALID_EXAMPLES.concat({
+            ...VALID_EXAMPLES[0],
+            message: BytesBlob.blobFromString("hello world"),
+        }));
+        assert.strictEqual(results, false);
+    });
+});
+const VALID_EXAMPLES = [
+    {
+        signature: "0xa3afee85825aefb49cfe10000b72d22321f6d562f89f57f56da813f62761130774e2540b2c0ce33da3c28fcbffe52ea0d1eccfbd859be46835128c4cc87fb50c",
+        key: "0x5c7f34a4bd4f2d04076a8c6f9060a0c8d2c6bdd082ceb3eda7df381cb260faff",
+        message: "0x6a616d5f617661696c61626c651835559f6ad24c3d86280d7725f696042094d83694947ad4a66be38b501e3d48",
+    },
+    {
+        signature: "0xdbd50734b049bcc9e25f5c4d2d2b635e22ec1d4eefcc324863de9e1673bacb4b7ac4424a946abae83755908a3f77470776c160e7d5b42991c1b8914bfc16b700",
+        key: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+        message: "0x6a616d5f617661696c61626c651835559f6ad24c3d86280d7725f696042094d83694947ad4a66be38b501e3d48",
+    },
+].map((x) => {
+    return {
+        signature: asOpaqueType(Bytes.parseBytes(x.signature, ED25519_SIGNATURE_BYTES)),
+        key: asOpaqueType(Bytes.parseBytes(x.key, ED25519_KEY_BYTES)),
+        message: BytesBlob.parseBlob(x.message),
+    };
+});

package/packages/core/crypto/index.d.ts

@@ -0,0 +1,11 @@
+export { bandersnatch as bandersnatchWasm, initAll as initWasm } from "@typeberry/native";
+export type { BandersnatchKey, BandersnatchProof, BandersnatchRingRoot, BandersnatchVrfSignature, BlsKey, } from "./bandersnatch.js";
+export * as bandersnatch from "./bandersnatch.js";
+export { BANDERSNATCH_KEY_BYTES, BANDERSNATCH_PROOF_BYTES, BANDERSNATCH_RING_ROOT_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, BLS_KEY_BYTES, } from "./bandersnatch.js";
+export type { Ed25519Key, Ed25519Signature } from "./ed25519.js";
+export * as ed25519 from "./ed25519.js";
+export { ED25519_KEY_BYTES, ED25519_PRIV_KEY_BYTES, ED25519_SIGNATURE_BYTES, Ed25519Pair } from "./ed25519.js";
+export type { BandersnatchSecretSeed, Ed25519SecretSeed, KeySeed as PublicKeySeed } from "./key-derivation.js";
+export * as keyDerivation from "./key-derivation.js";
+export { SEED_SIZE } from "./key-derivation.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/core/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/crypto/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC1F,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,wBAAwB,EACxB,MAAM,GACP,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAC;AAClD,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,gCAAgC,EAChC,aAAa,GACd,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE/G,YAAY,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/G,OAAO,KAAK,aAAa,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC"}

package/packages/core/crypto/index.js

@@ -0,0 +1,7 @@
+export { bandersnatch as bandersnatchWasm, initAll as initWasm } from "@typeberry/native";
+export * as bandersnatch from "./bandersnatch.js";
+export { BANDERSNATCH_KEY_BYTES, BANDERSNATCH_PROOF_BYTES, BANDERSNATCH_RING_ROOT_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, BLS_KEY_BYTES, } from "./bandersnatch.js";
+export * as ed25519 from "./ed25519.js";
+export { ED25519_KEY_BYTES, ED25519_PRIV_KEY_BYTES, ED25519_SIGNATURE_BYTES, Ed25519Pair } from "./ed25519.js";
+export * as keyDerivation from "./key-derivation.js";
+export { SEED_SIZE } from "./key-derivation.js";

package/packages/core/crypto/key-derivation.d.ts

@@ -0,0 +1,39 @@
+import { Bytes } from "#@typeberry/bytes";
+import type { Blake2b } from "#@typeberry/hash";
+import { type U32 } from "#@typeberry/numbers";
+import type { Opaque } from "#@typeberry/utils";
+import { type BandersnatchKey } from "./bandersnatch.js";
+import { type Ed25519Key } from "./ed25519.js";
+export declare const SEED_SIZE = 32;
+export type SEED_SIZE = typeof SEED_SIZE;
+export type KeySeed = Opaque<Bytes<SEED_SIZE>, "PublicKeySeed">;
+export type Ed25519SecretSeed = Opaque<Bytes<SEED_SIZE>, "Ed25519SecretSeed">;
+export type BandersnatchSecretSeed = Opaque<Bytes<SEED_SIZE>, "BandersnatchSecretSeed">;
+/**
+ * JIP-5: Secret key derivation
+ *
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md */
+/**
+ * Deriving a 32-byte seed from a 32-bit unsigned integer
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#trivial-seeds
+ */
+export declare function trivialSeed(s: U32): KeySeed;
+/**
+ * Derives a Ed25519 secret key from a seed.
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
+ */
+export declare function deriveEd25519SecretKey(seed: KeySeed, blake2b: Blake2b): Ed25519SecretSeed;
+/**
+ * Derives a Bandersnatch secret key from a seed.
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
+ */
+export declare function deriveBandersnatchSecretKey(seed: KeySeed, blake2b: Blake2b): BandersnatchSecretSeed;
+/**
+ * Derive Ed25519 public key from secret seed
+ */
+export declare function deriveEd25519PublicKey(seed: Ed25519SecretSeed): Promise<Ed25519Key>;
+/**
+ * Derive Bandersnatch public key from secret seed
+ */
+export declare function deriveBandersnatchPublicKey(seed: BandersnatchSecretSeed): BandersnatchKey;
+//# sourceMappingURL=key-derivation.d.ts.map

package/packages/core/crypto/key-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-derivation.d.ts","sourceRoot":"","sources":["../../../../../packages/core/crypto/key-derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,KAAK,GAAG,EAAgB,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,eAAe,EAAa,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,cAAc,CAAC;AAE3D,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AAKzC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,mBAAmB,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,wBAAwB,CAAC,CAAC;AAExF;;;qGAGqG;AAErG;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,GAAG,OAAO,CAM3C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAEzF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,sBAAsB,CAEnG;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAEzF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,sBAAsB,GAAG,eAAe,CAEzF"}

package/packages/core/crypto/key-derivation.js

@@ -0,0 +1,45 @@
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { u32AsLeBytes } from "#@typeberry/numbers";
+import { publicKey } from "./bandersnatch.js";
+import { privateKey } from "./ed25519.js";
+export const SEED_SIZE = 32;
+const ED25519_SECRET_KEY = Bytes.blobFromString("jam_val_key_ed25519");
+const BANDERSNATCH_SECRET_KEY = Bytes.blobFromString("jam_val_key_bandersnatch");
+/**
+ * JIP-5: Secret key derivation
+ *
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md */
+/**
+ * Deriving a 32-byte seed from a 32-bit unsigned integer
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#trivial-seeds
+ */
+export function trivialSeed(s) {
+    const s_le = u32AsLeBytes(s);
+    return Bytes.fromBlob(BytesBlob.blobFromParts([s_le, s_le, s_le, s_le, s_le, s_le, s_le, s_le]).raw, SEED_SIZE).asOpaque();
+}
+/**
+ * Derives a Ed25519 secret key from a seed.
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
+ */
+export function deriveEd25519SecretKey(seed, blake2b) {
+    return blake2b.hashBytes(BytesBlob.blobFromParts([ED25519_SECRET_KEY.raw, seed.raw])).asOpaque();
+}
+/**
+ * Derives a Bandersnatch secret key from a seed.
+ * https://github.com/polkadot-fellows/JIPs/blob/7048f79edf4f4eb8bfe6fb42e6bbf61900f44c65/JIP-5.md#derivation-method
+ */
+export function deriveBandersnatchSecretKey(seed, blake2b) {
+    return blake2b.hashBytes(BytesBlob.blobFromParts([BANDERSNATCH_SECRET_KEY.raw, seed.raw])).asOpaque();
+}
+/**
+ * Derive Ed25519 public key from secret seed
+ */
+export async function deriveEd25519PublicKey(seed) {
+    return (await privateKey(seed)).pubKey;
+}
+/**
+ * Derive Bandersnatch public key from secret seed
+ */
+export function deriveBandersnatchPublicKey(seed) {
+    return publicKey(seed.raw);
+}

package/packages/core/crypto/key-derivation.test.d.ts

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

package/packages/core/crypto/key-derivation.test.d.ts.map

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