@typeberry/lib 0.8.3 → 0.8.4-70b1490

package/packages/jam/node/main-fuzz.js

@@ -14,6 +14,9 @@ import { mainImporter } from "./main-importer.js";
 const logger = Logger.new(import.meta.filename, "fuzztarget");
 /** Dedicated subdirectory under the configured base path that the fuzzer owns and wipes. */
 const FUZZ_DB_SUBDIR = "typeberry-fuzz-db";
+const FUZZ_DB_FJALL = "fjall-hybrid";
+const FUZZ_DB_LMDB = "lmdb-hybrid";
+const FUZZ_DB_OPTIONS = [FUZZ_DB_FJALL, FUZZ_DB_LMDB];
 /**
  * Resolve the directory the fuzzer should use for its on-disk database, or
  * `undefined` for an in-memory database. The dedicated `FUZZ_DB_SUBDIR` is
@@ -50,6 +53,15 @@ export async function mainFuzz(fuzzConfig, withRelPath) {
     logHostEnvironment(logger);
     const { jamNodeConfig: config } = fuzzConfig;
     const fuzzDbBase = resolveFuzzDbBase(config.node.databaseBasePath);
+    const rawFuzzDb = process.env.JAM_FUZZ_DB?.trim() ?? "";
+    // Using experimental fjall-hybrid by default, with an option to test lmdb as well.
+    const hybridStateBackend = rawFuzzDb === "" ? FUZZ_DB_FJALL : rawFuzzDb;
+    if (!isValidStateBackend(hybridStateBackend)) {
+        throw new Error(`JAM_FUZZ_DB must be one of: ${FUZZ_DB_OPTIONS} (got: "${rawFuzzDb}").`);
+    }
+    if (fuzzDbBase !== undefined) {
+        logger.info `🗄️ Fuzz persistent backend: ${hybridStateBackend}.`;
+    }
     let runningNode = null;
     const chainSpec = getChainSpec(config.node.flavor);
     const closeFuzzTarget = startFuzzTarget(fuzzConfig.version, fuzzConfig.socket, {
@@ -101,10 +113,12 @@ export async function mainFuzz(fuzzConfig, withRelPath) {
                     // like the in-memory backend; only the large values live on disk.
                     dummyFinalityDepth: 20,
                     pruneBlocks: true,
-                    // The fuzz db is wiped on every reset, so durability is pointless:
-                    // skip fsync + compression to cut the per-block value write cost.
-                    ephemeralDb: isPersistent,
-                    stateBackend: isPersistent ? "hybrid" : "lmdb",
+                    // Long full-spec sessions accumulate a large, never-pruned values db.
+                    // Syncing lets the OS reclaim dirty mmap pages, and compression (full
+                    // spec only, where values are big) bounds its on-disk/page-cache size.
+                    // Tiny stays uncompressed since its db is small and speed matters more.
+                    ephemeral: isPersistent,
+                    stateBackend: isPersistent ? hybridStateBackend : "lmdb",
                 });
             };
             if (fuzzDbBase !== undefined) {
@@ -134,3 +148,6 @@ export async function mainFuzz(fuzzConfig, withRelPath) {
         }
     };
 }
+function isValidStateBackend(val) {
+    return FUZZ_DB_OPTIONS.indexOf(val) !== -1;
+}

package/packages/jam/node/main-importer.d.ts

@@ -1,13 +1,16 @@
 import type { JamConfig } from "./jam-config.js";
 import type { NodeApi } from "./main.js";
+export type StateBackend = "lmdb" | "lmdb-hybrid" | "fjall-hybrid";
 export type ImporterOptions = {
     initGenesisFromAncestry?: boolean;
     dummyFinalityDepth?: number;
     pruneBlocks?: boolean;
-    /** Open the LMDB database without fsync/compression. Only safe for throwaway dbs (e.g. fuzzing). */
-    ephemeralDb?: boolean;
-    /** Persistent backend to use when `databaseBasePath` is set. Defaults to full LMDB. */
-    stateBackend?: "lmdb" | "hybrid";
+    /** Open the database without fsync/compression. Only safe for throwaway dbs (e.g. fuzzing). */
+    ephemeral?: boolean;
+    /**
+     * Persistent backend to use when `databaseBasePath` is set. Defaults to full LMDB.
+     */
+    stateBackend?: StateBackend;
 };
 export declare function mainImporter(config: JamConfig, withRelPath: (v: string) => string, options?: ImporterOptions): Promise<NodeApi>;
 //# sourceMappingURL=main-importer.d.ts.map

package/packages/jam/node/main-importer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main-importer.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main-importer.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,MAAM,MAAM,eAAe,GAAG;IAC5B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oGAAoG;IACpG,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,uFAAuF;IACvF,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CAClC,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CA+FlB"}
+{"version":3,"file":"main-importer.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/node/main-importer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,aAAa,GAAG,cAAc,CAAC;AAEnE,MAAM,MAAM,eAAe,GAAG;IAC5B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,+FAA+F;IAC/F,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAClC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAqGlB"}

package/packages/jam/node/main-importer.js

@@ -1,5 +1,6 @@
 import { Bytes } from "#@typeberry/bytes";
 import { PvmBackend } from "#@typeberry/config";
+import { KnownChainSpec } from "#@typeberry/config-node";
 import { bandersnatch, initWasm } from "#@typeberry/crypto";
 import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
 import { createImporter, ImporterConfig } from "#@typeberry/importer";
@@ -28,6 +29,9 @@ export async function mainImporter(config, withRelPath, options = {}) {
         dummyFinalityDepth: tryAsU16(options.dummyFinalityDepth ?? 0),
         pruneBlocks: options.pruneBlocks ?? false,
     });
+    const ephemeral = options.ephemeral ?? false;
+    // enable compression when running full test suite
+    const compression = ephemeral && config.node.flavor === KnownChainSpec.Full;
     const workerConfig = dbBackend === "in-memory"
         ? InMemWorkerConfig.new({
             nodeName,
@@ -35,14 +39,16 @@ export async function mainImporter(config, withRelPath, options = {}) {
             blake2b,
             workerParams,
         })
-        : dbBackend === "hybrid"
-            ? HybridWorkerConfig.new({
+        : dbBackend === "lmdb-hybrid" || dbBackend === "fjall-hybrid"
+            ? await HybridWorkerConfig.new({
                 nodeName,
                 chainSpec,
                 blake2b,
                 dbPath,
                 workerParams,
-                ephemeral: options.ephemeralDb ?? false,
+                ephemeral,
+                compression,
+                backend: dbBackend === "lmdb-hybrid" ? "lmdb" : "fjall",
             })
             : LmdbWorkerConfig.new({
                 nodeName,
@@ -50,7 +56,7 @@ export async function mainImporter(config, withRelPath, options = {}) {
                 blake2b,
                 dbPath,
                 workerParams,
-                ephemeral: options.ephemeralDb ?? false,
+                ephemeral,
             });
     // Initialize the database with genesis state and block if there isn't one.
     logger.info `🛢️ Opening database at ${dbPath}`;

package/packages/jam/safrole/bandersnatch-vrf.d.ts

@@ -21,13 +21,33 @@ declare function verifySeal(bandersnatch: BandernsatchWasm, authorKey: Bandersna
 declare function getRingCommitment(bandersnatch: BandernsatchWasm, validators: BandersnatchKey[]): Promise<Result<BandersnatchRingRoot, null>>;
 declare function verifyTickets(bandersnatch: BandernsatchWasm, numberOfValidators: number, epochRoot: BandersnatchRingRoot, tickets: readonly SignedTicket[], entropy: EntropyHash): Promise<{
     isValid: boolean;
-    entropyHash: EntropyHash;
-}[]>;
+    tickets: EntropyHash[];
+}>;
 declare function generateSeal(bandersnatch: BandernsatchWasm, authorKey: BandersnatchSecretSeed, input: BytesBlob, auxData: BytesBlob): Promise<Result<BandersnatchVrfSignature, null>>;
 export type VrfOutputHash = Opaque<OpaqueHash, "VRF Output Hash">;
 declare function getVrfOutputHash(bandersnatch: BandernsatchWasm, authorKey: BandersnatchSecretSeed, input: BytesBlob): Promise<Result<VrfOutputHash, null>>;
 /**
- * Generates signed tickets for all attempts at once using batch ring VRF.
+ * Batch-generate signed tickets for multiple validators in a single native call,
+ * reusing the ring prover setup across all of them. Returns one ticket list per
+ * validator, in the same order as `proverKeyIndices`/`secrets`.
  */
-declare function generateTickets(bandersnatch: BandernsatchWasm, ringKeys: BandersnatchKey[], proverKeyIndex: number, key: BandersnatchSecretSeed, entropy: EntropyHash, ticketsPerValidator: number): Promise<Result<SignedTicket[], null>>;
+declare function generateTickets(bandersnatch: BandernsatchWasm, ringKeys: BandersnatchKey[], proverKeyIndices: readonly number[], secrets: readonly BandersnatchSecretSeed[], entropy: EntropyHash, ticketsPerValidator: number): Promise<Result<SignedTicket[][], null>>;
+/**
+ * Build the concatenated ring-VRF inputs for ticket generation: one
+ * `JAM_TICKET_SEAL || entropy || attempt_byte` input per attempt.
+ *
+ * Exposed so the worker-pool path can build the same inputs to hand off to a
+ * worker thread without re-deriving the layout.
+ */
+export declare function buildTicketVrfInputs(entropy: EntropyHash, ticketsPerValidator: number): {
+    inputsData: Uint8Array;
+    vrfInputDataLen: number;
+};
+/**
+ * Parse the raw output of `batchGenerateRingVrfForValidators` into per-validator
+ * ticket lists. Records are ordered validator-major, then attempt-major; each
+ * record is `status byte || signature`. A malformed batch yields a single error
+ * byte. Exposed so the worker-pool path can parse a worker's raw result.
+ */
+export declare function parseTicketsBatchOutput(result: Uint8Array, numValidators: number, ticketsPerValidator: number): Result<SignedTicket[][], null>;
 //# sourceMappingURL=bandersnatch-vrf.d.ts.map

package/packages/jam/safrole/bandersnatch-vrf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bandersnatch-vrf.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-vrf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAsB,MAAM,6BAA6B,CAAC;AAC/E,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAwB/D,QAAA,MAAM,SAAS;;;;;;;;CAQd,CAAC;AAKF,eAAe,SAAS,CAAC;AAEzB,iBAAe,iBAAiB,CAC9B,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,OAAO,EAAE,SAAS,EAClB,qBAAqB,EAAE,SAAS,EAChC,gBAAgB,EAAE,wBAAwB,EAC1C,oBAAoB,EAAE,SAAS,GAC9B,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC,CAkBnD;AAED,iBAAe,UAAU,CACvB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,OAAO,EAAE,SAAS,EAClB,qBAAqB,EAAE,SAAS,GAC/B,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAapC;AAED,iBAAS,iBAAiB,CACxB,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,eAAe,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,CAmB7C;AAkBD,iBAAe,aAAa,CAC1B,YAAY,EAAE,gBAAgB,EAC9B,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,WAAW,CAAA;CAAE,EAAE,CAAC,CAqB3D;AAED,iBAAe,YAAY,CACzB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,SAAS,GACjB,OAAO,CAAC,MAAM,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC,CAQjD;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;AAElE,iBAAe,gBAAgB,CAC7B,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAQtC;AAKD;;GAEG;AACH,iBAAe,eAAe,CAC5B,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,eAAe,EAAE,EAC3B,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,sBAAsB,EAC3B,OAAO,EAAE,WAAW,EACpB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,CAAC,CA0CvC"}
+{"version":3,"file":"bandersnatch-vrf.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-vrf.ts"],"names":[],"mappings":"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"}

package/packages/jam/safrole/bandersnatch-vrf.js

@@ -1,5 +1,6 @@
 import { SignedTicket, tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
 import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { SEED_SIZE } from "#@typeberry/crypto";
 import { BANDERSNATCH_PROOF_BYTES, BANDERSNATCH_RING_ROOT_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, } from "#@typeberry/crypto/bandersnatch.js";
 import { HASH_SIZE } from "#@typeberry/hash";
 import { Result } from "#@typeberry/utils";
@@ -17,8 +18,27 @@ var ResultValues;
  * to overcome that we cache the results of getting ring commitment.
  * Note we can also tentatively populate this cache, before we even
  * reach the epoch change block.
+ *
+ * Keep number of entries low here, since matching is done by fully
+ * comparing the keys.
+ * To avoid array re-allocation we keep it's size constant and use
+ * index.
  */
-const ringCommitmentCache = [];
+let ringCommitmentIndex = 0;
+const ringCommitmentCache = [
+    {
+        keys: BytesBlob.empty(),
+        value: Promise.resolve(Result.error(null, () => "")),
+    },
+    {
+        keys: BytesBlob.empty(),
+        value: Promise.resolve(Result.error(null, () => "")),
+    },
+    {
+        keys: BytesBlob.empty(),
+        value: Promise.resolve(Result.error(null, () => "")),
+    },
+];
 const FUNCTIONS = {
     verifySeal,
     verifyHeaderSeals,
@@ -32,10 +52,11 @@ const FUNCTIONS = {
 // Ideally we would just export functions and figure out how to mock
 // properly in ESM.
 export default FUNCTIONS;
+const VRF_SEAL_VERIFICATION_FAILED = () => "Bandersnatch VRF seal verification failed";
 async function verifyHeaderSeals(bandersnatch, authorKey, signature, payload, encodedUnsealedHeader, entropySignature, entropyPayloadPrefix) {
     const sealResult = await bandersnatch.verifyHeaderSeals(authorKey.raw, signature.raw, payload.raw, encodedUnsealedHeader.raw, entropySignature.raw, entropyPayloadPrefix.raw);
     if (sealResult[RESULT_INDEX] === ResultValues.Error) {
-        return Result.error(null, () => "Bandersnatch VRF seal verification failed");
+        return Result.error(null, VRF_SEAL_VERIFICATION_FAILED);
     }
     return Result.ok([
         Bytes.fromBlob(sealResult.subarray(1, 33), HASH_SIZE).asOpaque(),
@@ -45,90 +66,121 @@ async function verifyHeaderSeals(bandersnatch, authorKey, signature, payload, en
 async function verifySeal(bandersnatch, authorKey, signature, payload, encodedUnsealedHeader) {
     const sealResult = await bandersnatch.verifySeal(authorKey.raw, signature.raw, payload.raw, encodedUnsealedHeader.raw);
     if (sealResult[RESULT_INDEX] === ResultValues.Error) {
-        return Result.error(null, () => "Bandersnatch VRF seal verification failed");
+        return Result.error(null, VRF_SEAL_VERIFICATION_FAILED);
     }
     return Result.ok(Bytes.fromBlob(sealResult.subarray(1), HASH_SIZE).asOpaque());
 }
 function getRingCommitment(bandersnatch, validators) {
     const keys = BytesBlob.blobFromParts(validators.map((x) => x.raw));
-    // We currently compare the large bytes blob, but the number of entries in the cache
-    // must be low. If the cache ever grows larger, we should rather consider hashing the keys.
-    const MAX_CACHE_ENTRIES = 3;
     const cacheEntry = ringCommitmentCache.find((v) => v.keys.isEqualTo(keys));
     if (cacheEntry !== undefined) {
         return cacheEntry.value;
     }
     const value = getRingCommitmentNoCache(bandersnatch, keys);
-    ringCommitmentCache.push({
+    ringCommitmentCache[ringCommitmentIndex] = {
         keys,
         value,
-    });
-    if (ringCommitmentCache.length > MAX_CACHE_ENTRIES) {
-        ringCommitmentCache.shift();
-    }
+    };
+    // move the index to point at next entry to override.
+    ringCommitmentIndex = (ringCommitmentIndex + 1) % ringCommitmentCache.length;
     return value;
 }
+const RING_COMMITMENT_FAILED = () => "Bandersnatch ring commitment calculation failed";
 async function getRingCommitmentNoCache(bandersnatch, keys) {
     const commitmentResult = await bandersnatch.getRingCommitment(keys.raw);
     if (commitmentResult[RESULT_INDEX] === ResultValues.Error) {
-        return Result.error(null, () => "Bandersnatch ring commitment calculation failed");
+        return Result.error(null, RING_COMMITMENT_FAILED);
     }
     return Result.ok(Bytes.fromBlob(commitmentResult.subarray(1), BANDERSNATCH_RING_ROOT_BYTES).asOpaque());
 }
-// One byte for result discriminator (`ResultValues`) and the rest is entropy hash.
-const TICKET_RESULT_LENGTH = 1 + HASH_SIZE;
 async function verifyTickets(bandersnatch, numberOfValidators, epochRoot, tickets, entropy) {
     const contextLength = entropy.length + JAM_TICKET_SEAL.length + 1;
     const ticketsData = BytesBlob.blobFromParts(tickets.map((ticket) => BytesBlob.blobFromParts([ticket.signature.raw, JAM_TICKET_SEAL, entropy.raw, Uint8Array.of(ticket.attempt)])
         .raw)).raw;
     const verificationResult = await bandersnatch.batchVerifyTicket(numberOfValidators, epochRoot.raw, ticketsData, contextLength);
-    return Array.from(BytesBlob.blobFrom(verificationResult).chunks(TICKET_RESULT_LENGTH)).map((result) => ({
-        isValid: result.raw[RESULT_INDEX] === ResultValues.Ok,
-        entropyHash: Bytes.fromBlob(result.raw.subarray(1, TICKET_RESULT_LENGTH), HASH_SIZE).asOpaque(),
-    }));
+    const isValid = verificationResult[RESULT_INDEX] === ResultValues.Ok;
+    // NOTE: in case of failure, the hashes will be all zeros, but we can safely
+    // keep the same code path.
+    const chunks = BytesBlob.blobFrom(verificationResult.subarray(1)).chunks(HASH_SIZE);
+    const results = [];
+    for (const entropyHash of chunks) {
+        results.push(Bytes.fromBlob(entropyHash.raw, HASH_SIZE).asOpaque());
+    }
+    return { isValid, tickets: results };
 }
+const SEAL_FAILED_ERROR = () => "Seal generation failed";
 async function generateSeal(bandersnatch, authorKey, input, auxData) {
     const result = await bandersnatch.generateSeal(authorKey.raw, input.raw, auxData.raw);
     if (result[RESULT_INDEX] === ResultValues.Error) {
-        return Result.error(null, () => "Seal generation failed");
+        return Result.error(null, SEAL_FAILED_ERROR);
     }
     return Result.ok(Bytes.fromBlob(result.subarray(1), BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque());
 }
+const VRF_OUTPUT_FAILED = () => "VRF output hash generation failed";
 async function getVrfOutputHash(bandersnatch, authorKey, input) {
     const result = await bandersnatch.getVrfOutputHash(authorKey.raw, input.raw);
     if (result[RESULT_INDEX] === ResultValues.Error) {
-        return Result.error(null, () => "VRF output hash generation failed");
+        return Result.error(null, VRF_OUTPUT_FAILED);
     }
     return Result.ok(Bytes.fromBlob(result.subarray(1), HASH_SIZE).asOpaque());
 }
 // One byte for result discriminator and the rest is the ring VRF signature.
 const GENERATE_RESULT_ENTRY_LENGTH = 1 + BANDERSNATCH_PROOF_BYTES;
 /**
- * Generates signed tickets for all attempts at once using batch ring VRF.
+ * Batch-generate signed tickets for multiple validators in a single native call,
+ * reusing the ring prover setup across all of them. Returns one ticket list per
+ * validator, in the same order as `proverKeyIndices`/`secrets`.
  */
-async function generateTickets(bandersnatch, ringKeys, proverKeyIndex, key, entropy, ticketsPerValidator) {
-    // Build VRF inputs: JAM_TICKET_SEAL || entropy || attempt_byte for each attempt
+async function generateTickets(bandersnatch, ringKeys, proverKeyIndices, secrets, entropy, ticketsPerValidator) {
+    if (proverKeyIndices.length !== secrets.length) {
+        return Result.error(null, () => "proverKeyIndices and secrets must have the same length");
+    }
+    if (proverKeyIndices.length === 0) {
+        return Result.ok([]);
+    }
+    const { inputsData, vrfInputDataLen } = buildTicketVrfInputs(entropy, ticketsPerValidator);
+    const ringKeysData = BytesBlob.blobFromParts(ringKeys.map((k) => k.raw)).raw;
+    const secretSeedsData = BytesBlob.blobFromParts(secrets.map((s) => s.raw)).raw;
+    const result = await bandersnatch.batchGenerateRingVrfForValidators(ringKeysData, Uint32Array.from(proverKeyIndices), secretSeedsData, SEED_SIZE, inputsData, vrfInputDataLen);
+    return parseTicketsBatchOutput(result, proverKeyIndices.length, ticketsPerValidator);
+}
+/**
+ * Build the concatenated ring-VRF inputs for ticket generation: one
+ * `JAM_TICKET_SEAL || entropy || attempt_byte` input per attempt.
+ *
+ * Exposed so the worker-pool path can build the same inputs to hand off to a
+ * worker thread without re-deriving the layout.
+ */
+export function buildTicketVrfInputs(entropy, ticketsPerValidator) {
     const vrfInputParts = [];
     for (let attempt = 0; attempt < ticketsPerValidator; attempt++) {
         vrfInputParts.push(BytesBlob.blobFromParts([JAM_TICKET_SEAL, entropy.raw, Uint8Array.of(attempt)]).raw);
     }
-    const attemptLength = 1;
-    const vrfInputDataLen = JAM_TICKET_SEAL.length + entropy.length + attemptLength;
-    const inputsData = BytesBlob.blobFromParts(vrfInputParts).raw;
-    const ringKeysData = BytesBlob.blobFromParts(ringKeys.map((k) => k.raw)).raw;
-    const result = await bandersnatch.batchGenerateRingVrf(ringKeysData, proverKeyIndex, key.raw, inputsData, vrfInputDataLen);
-    const tickets = [];
-    for (let attempt = 0; attempt < ticketsPerValidator; attempt++) {
-        const offset = attempt * GENERATE_RESULT_ENTRY_LENGTH;
-        const resultByte = result[offset];
-        if (resultByte === ResultValues.Error) {
-            return Result.error(null, () => `Ring VRF proof generation failed for attempt ${attempt}`);
+    return {
+        inputsData: BytesBlob.blobFromParts(vrfInputParts).raw,
+        vrfInputDataLen: JAM_TICKET_SEAL.length + entropy.length + 1,
+    };
+}
+/**
+ * Parse the raw output of `batchGenerateRingVrfForValidators` into per-validator
+ * ticket lists. Records are ordered validator-major, then attempt-major; each
+ * record is `status byte || signature`. A malformed batch yields a single error
+ * byte. Exposed so the worker-pool path can parse a worker's raw result.
+ */
+export function parseTicketsBatchOutput(result, numValidators, ticketsPerValidator) {
+    const perValidator = [];
+    let offset = 0;
+    for (let v = 0; v < numValidators; v++) {
+        const tickets = [];
+        for (let attempt = 0; attempt < ticketsPerValidator; attempt++) {
+            if (result[offset] === ResultValues.Error) {
+                return Result.error(null, () => `Ring VRF proof generation failed for validator ${v}, attempt ${attempt}`);
+            }
+            const signature = Bytes.fromBlob(result.subarray(offset + 1, offset + GENERATE_RESULT_ENTRY_LENGTH), BANDERSNATCH_PROOF_BYTES).asOpaque();
+            tickets.push(SignedTicket.create({ attempt: tryAsTicketAttempt(attempt), signature }));
+            offset += GENERATE_RESULT_ENTRY_LENGTH;
         }
-        const signature = Bytes.fromBlob(new Uint8Array(result.subarray(offset + 1, offset + GENERATE_RESULT_ENTRY_LENGTH)), BANDERSNATCH_PROOF_BYTES).asOpaque();
-        tickets.push(SignedTicket.create({
-            attempt: tryAsTicketAttempt(attempt),
-            signature,
-        }));
+        perValidator.push(tickets);
     }
-    return Result.ok(tickets);
+    return Result.ok(perValidator);
 }

package/packages/jam/safrole/bandersnatch-vrf.test.js

@@ -71,8 +71,8 @@ describe("Bandersnatch verification", () => {
                 "0x3a5d10abc80dda33fe3f40b3bb2e3eefd3e97dda3d617a860c9d94eb70b832ad",
             ].map((x) => Bytes.parseBytes(x, HASH_SIZE));
             const result = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, bandersnatchKeys.length, commitment, tickets, entropy);
-            assert.strictEqual(result.every((x) => x.isValid), true);
-            assert.deepStrictEqual(result.map((x) => x.entropyHash.toString()), expectedIds.map((x) => x.toString()));
+            assert.strictEqual(result.isValid, true);
+            assert.deepStrictEqual(result.tickets.map((x) => x.toString()), expectedIds.map((x) => x.toString()));
         });
         it("should detect that one signature is incorrect", async () => {
             const tickets = [
@@ -90,14 +90,16 @@ describe("Bandersnatch verification", () => {
                 },
             ];
             const entropy = Bytes.parseBytes("0xbb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa", HASH_SIZE).asOpaque();
+            // Batch verification fails as a whole when any signature is invalid,
+            // and in that case all returned entropy hashes are zeroed out.
             const expectedIds = [
                 "0x0000000000000000000000000000000000000000000000000000000000000000",
-                "0x13fecb426e0a73b84b58b9a0832b11582dc971e79c5399e69f0baf1a244c7787",
-                "0x3a5d10abc80dda33fe3f40b3bb2e3eefd3e97dda3d617a860c9d94eb70b832ad",
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
             ].map((x) => Bytes.parseBytes(x, HASH_SIZE));
             const result = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, bandersnatchKeys.length, commitment, tickets, entropy);
-            assert.deepStrictEqual(result.map((x) => x.isValid), [false, true, true]);
-            assert.deepStrictEqual(result.map((x) => x.entropyHash.toString()), expectedIds.map((x) => x.toString()));
+            assert.strictEqual(result.isValid, false);
+            assert.deepStrictEqual(result.tickets.map((x) => x.toString()), expectedIds.map((x) => x.toString()));
         });
     });
     describe("verifySeal", () => {
@@ -163,12 +165,13 @@ describe("Bandersnatch verification", () => {
             const ringKeys = secrets.map((secret) => deriveBandersnatchPublicKey(secret));
             const proverIndex = 0;
             const entropy = Bytes.fill(HASH_SIZE, 123).asOpaque();
-            const genResult = await bandersnatchVrf.generateTickets(await bandersnatchWasm, ringKeys, proverIndex, secrets[proverIndex], entropy, 2);
+            const genResult = await bandersnatchVrf.generateTickets(await bandersnatchWasm, ringKeys, [proverIndex], [secrets[proverIndex]], entropy, 2);
             assert.ok(genResult.isOk);
             const commitment = await bandersnatchVrf.getRingCommitment(await bandersnatchWasm, ringKeys);
             assert.ok(commitment.isOk);
-            const verifyResult = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, ringKeys.length, commitment.ok, genResult.ok, entropy);
-            assert.ok(verifyResult.every((r) => r.isValid), "Generated tickets should pass verification");
+            assert.strictEqual(genResult.ok.length, 1);
+            const verifyResult = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, ringKeys.length, commitment.ok, genResult.ok[0], entropy);
+            assert.ok(verifyResult.isValid, "Generated tickets should pass verification");
         });
     });
 });

package/packages/jam/safrole/bandersnatch-wasm.d.ts

@@ -8,5 +8,15 @@ export declare class BandernsatchWasm {
     generateSeal(authorKey: Uint8Array, input: Uint8Array, auxData: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     getVrfOutputHash(authorKey: Uint8Array, input: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     batchGenerateRingVrf(ringKeys: Uint8Array, proverKeyIndex: number, secretSeed: Uint8Array, inputsData: Uint8Array, vrfInputDataLen: number): Promise<Uint8Array<ArrayBufferLike>>;
+    /**
+     * Batch-generate ring VRF tickets for multiple validators in a single call,
+     * reusing the ring prover setup across all of them.
+     *
+     * `secretSeedsData` is the fixed-width concatenation of the validators' secret
+     * seeds (each `secretSeedDataLen` bytes); `proverKeyIndices` are their indices
+     * within the ring and must have the same count. Output records are ordered
+     * validator-major then input-major, each `status byte || signature`.
+     */
+    batchGenerateRingVrfForValidators(ringKeys: Uint8Array, proverKeyIndices: Uint32Array, secretSeedsData: Uint8Array, secretSeedDataLen: number, inputsData: Uint8Array, vrfInputDataLen: number): Promise<Uint8Array<ArrayBufferLike>>;
 }
 //# sourceMappingURL=bandersnatch-wasm.d.ts.map

package/packages/jam/safrole/bandersnatch-wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bandersnatch-wasm.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-wasm.ts"],"names":[],"mappings":"AAEA,qBAAa,gBAAgB;IAC3B,OAAO;WAEM,GAAG;IAKV,UAAU,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAIjG,iBAAiB,CACrB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,UAAU,EACtB,iBAAiB,EAAE,UAAU,EAC7B,cAAc,EAAE,UAAU,EAC1B,WAAW,EAAE,UAAU,EACvB,oBAAoB,EAAE,UAAU;IAY5B,iBAAiB,CAAC,IAAI,EAAE,UAAU;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM;IAI1G,YAAY,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAI1E,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAIzD,oBAAoB,CACxB,QAAQ,EAAE,UAAU,EACpB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,MAAM;CAI1B"}
+{"version":3,"file":"bandersnatch-wasm.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-wasm.ts"],"names":[],"mappings":"AAEA,qBAAa,gBAAgB;IAC3B,OAAO;WAEM,GAAG;IAKV,UAAU,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAIjG,iBAAiB,CACrB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,UAAU,EACtB,iBAAiB,EAAE,UAAU,EAC7B,cAAc,EAAE,UAAU,EAC1B,WAAW,EAAE,UAAU,EACvB,oBAAoB,EAAE,UAAU;IAY5B,iBAAiB,CAAC,IAAI,EAAE,UAAU;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM;IAI1G,YAAY,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAI1E,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;IAIzD,oBAAoB,CACxB,QAAQ,EAAE,UAAU,EACpB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,MAAM;IAKzB;;;;;;;;OAQG;IACG,iCAAiC,CACrC,QAAQ,EAAE,UAAU,EACpB,gBAAgB,EAAE,WAAW,EAC7B,eAAe,EAAE,UAAU,EAC3B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,MAAM;CAW1B"}

package/packages/jam/safrole/bandersnatch-wasm.js

@@ -26,4 +26,16 @@ export class BandernsatchWasm {
     async batchGenerateRingVrf(ringKeys, proverKeyIndex, secretSeed, inputsData, vrfInputDataLen) {
         return bandersnatchWasm.batchGenerateRingVrf(ringKeys, proverKeyIndex, secretSeed, inputsData, vrfInputDataLen);
     }
+    /**
+     * Batch-generate ring VRF tickets for multiple validators in a single call,
+     * reusing the ring prover setup across all of them.
+     *
+     * `secretSeedsData` is the fixed-width concatenation of the validators' secret
+     * seeds (each `secretSeedDataLen` bytes); `proverKeyIndices` are their indices
+     * within the ring and must have the same count. Output records are ordered
+     * validator-major then input-major, each `status byte || signature`.
+     */
+    async batchGenerateRingVrfForValidators(ringKeys, proverKeyIndices, secretSeedsData, secretSeedDataLen, inputsData, vrfInputDataLen) {
+        return bandersnatchWasm.batchGenerateRingVrfForValidators(ringKeys, proverKeyIndices, secretSeedsData, secretSeedDataLen, inputsData, vrfInputDataLen);
+    }
 }

package/packages/jam/safrole/safrole.js

@@ -260,15 +260,15 @@ export class Safrole {
          */
         // TODO [ToDr] Verify that ticket attempt is in correct range.
         const verificationResult = extrinsic.length === 0
-            ? []
+            ? { isValid: true, tickets: [] }
             : await bandersnatchVrf.verifyTickets(await this.bandersnatch, validators.length, epochRoot, extrinsic, entropy);
+        if (!verificationResult.isValid) {
+            return Result.error(SafroleErrorCode.BadTicketProof, () => "Safrole: invalid ticket proof in extrinsic");
+        }
         const tickets = extrinsic.map((ticket, i) => ({
-            id: verificationResult[i].entropyHash,
+            id: verificationResult.tickets[i],
             attempt: ticket.attempt,
         }));
-        if (!verificationResult.every((x) => x.isValid)) {
-            return Result.error(SafroleErrorCode.BadTicketProof, () => "Safrole: invalid ticket proof in extrinsic");
-        }
         /**
          * Verify if tickets are sorted and unique
          *

package/packages/jam/safrole/safrole.test.js

@@ -67,10 +67,10 @@ const fakeSealingKeys = {
 describe("Safrole", () => {
     let blake2b;
     beforeEach(async () => {
-        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve([
-            { isValid: true, entropyHash: Bytes.zero(HASH_SIZE) },
-            { isValid: true, entropyHash: Bytes.fill(HASH_SIZE, 1) },
-        ]));
+        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve({
+            isValid: true,
+            tickets: [Bytes.zero(HASH_SIZE), Bytes.fill(HASH_SIZE, 1)],
+        }));
         blake2b = await Blake2b.createHasher();
     });
     afterEach(() => {
@@ -146,7 +146,7 @@ describe("Safrole", () => {
         }
     });
     it("should return bad ticket proof error", async () => {
-        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve([{ isValid: false, entropyHash: Bytes.zero(HASH_SIZE) }]));
+        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve({ isValid: false, tickets: [Bytes.zero(HASH_SIZE)] }));
         const punishSet = SortedSet.fromArray(hashComparator);
         const state = {
             timeslot: tryAsTimeSlot(1),
@@ -188,10 +188,10 @@ describe("Safrole", () => {
         }
     });
     it("should return duplicated ticket error", async () => {
-        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve([
-            { isValid: true, entropyHash: Bytes.zero(HASH_SIZE) },
-            { isValid: true, entropyHash: Bytes.zero(HASH_SIZE) },
-        ]));
+        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve({
+            isValid: true,
+            tickets: [Bytes.zero(HASH_SIZE), Bytes.zero(HASH_SIZE)],
+        }));
         const punishSet = SortedSet.fromArray(hashComparator);
         const state = {
             timeslot: tryAsTimeSlot(1),
@@ -237,10 +237,10 @@ describe("Safrole", () => {
         }
     });
     it("should return bad ticket order error", async () => {
-        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve([
-            { isValid: true, entropyHash: Bytes.fill(HASH_SIZE, 1) },
-            { isValid: true, entropyHash: Bytes.zero(HASH_SIZE) },
-        ]));
+        mock.method(bandersnatchVrf, "verifyTickets", () => Promise.resolve({
+            isValid: true,
+            tickets: [Bytes.fill(HASH_SIZE, 1), Bytes.zero(HASH_SIZE)],
+        }));
         const punishSet = SortedSet.fromArray(hashComparator);
         const state = {
             timeslot: tryAsTimeSlot(1),

package/packages/jam/ticket-pool/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./pending-ticket-pool.js";
+export * from "./ticket-validator.js";
+export * from "./verified-ticket-pool.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/ticket-pool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/ticket-pool/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC"}

package/packages/jam/ticket-pool/index.js

@@ -0,0 +1,3 @@
+export * from "./pending-ticket-pool.js";
+export * from "./ticket-validator.js";
+export * from "./verified-ticket-pool.js";

package/packages/jam/ticket-pool/pending-ticket-pool.d.ts

@@ -0,0 +1,30 @@
+import type { Epoch } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+/**
+ * An ordered, signature-deduplicated pool of tickets waiting to be redistributed to peers.
+ *
+ * Used on the networking side. Indices are stable within an epoch so callers can track
+ * per-peer "sent" sets by index. The pool is cleared whenever a new epoch is observed,
+ * and tickets for older epochs are dropped (can happen when an async validation completes
+ * after the epoch already advanced).
+ */
+export declare class PendingTicketPool {
+    private tickets;
+    private currentEpochValue;
+    /** Epoch the pool is currently holding tickets for, or `null` if empty. */
+    get currentEpoch(): Epoch | null;
+    /** Returns the ordered tickets currently in the pool. Caller must not mutate the array. */
+    getTickets(): readonly {
+        epochIndex: Epoch;
+        ticket: SignedTicket;
+    }[];
+    /** Returns true if the ticket was added, false if it was a duplicate or dropped (old epoch). */
+    addTicket(epochIndex: Epoch, ticket: SignedTicket): boolean;
+    /**
+     * Replace the pool contents for the given epoch with the supplied tickets. Used when the
+     * authorship worker pushes an authoritative pool dump on an epoch boundary; any tickets
+     * that aren't in the dump are dropped, and dedup runs over the new set.
+     */
+    replace(epochIndex: Epoch, tickets: readonly SignedTicket[]): void;
+}
+//# sourceMappingURL=pending-ticket-pool.d.ts.map

package/packages/jam/ticket-pool/pending-ticket-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-ticket-pool.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/ticket-pool/pending-ticket-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAA0D;IACzE,OAAO,CAAC,iBAAiB,CAAsB;IAE/C,2EAA2E;IAC3E,IAAI,YAAY,IAAI,KAAK,GAAG,IAAI,CAE/B;IAED,2FAA2F;IAC3F,UAAU,IAAI,SAAS;QAAE,UAAU,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE;IAIpE,gGAAgG;IAChG,SAAS,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO;IAyB3D;;;;OAIG;IACH,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,IAAI;CAWnE"}