@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/rpc-validation/validation.js

@@ -0,0 +1,181 @@
+import { HASH_SIZE } from "#@typeberry/hash";
+import z from "zod";
+export const JSON_RPC_VERSION = "2.0";
+export var validation;
+(function (validation) {
+    const u32 = z.number().int().min(0).max(0xffffffff);
+    const uint8Array = z.custom((v) => v instanceof Uint8Array); // this is needed because a simple z.instanceof(Uint8Array) automatically narrows the type down to Uint8Array<ArrayBuffer> whereas our Bytes.raw are effectively Uint8Array<ArrayBufferLike>
+    validation.hash = z.codec(z.base64(), uint8Array.refine((v) => v.length === HASH_SIZE, "Invalid hash length."), {
+        decode: (v) => Uint8Array.from(Buffer.from(v, "base64")),
+        encode: (v) => Buffer.from(v).toString("base64"),
+    });
+    validation.slot = u32;
+    validation.blobArray = z.codec(z.base64(), uint8Array, {
+        decode: (v) => Uint8Array.from(Buffer.from(v, "base64")),
+        encode: (v) => Buffer.from(v).toString("base64"),
+    });
+    validation.serviceId = u32;
+    validation.preimageLength = u32;
+    validation.noArgs = z.tuple([]);
+    validation.blockDescriptor = z.object({
+        header_hash: validation.hash,
+        slot: validation.slot,
+    });
+    validation.parameters = z.object({
+        V1: z.object({
+            deposit_per_account: z.number(),
+            deposit_per_item: z.number(),
+            deposit_per_byte: z.number(),
+            min_turnaround_period: z.number(),
+            epoch_period: z.number(),
+            max_accumulate_gas: z.number(),
+            max_is_authorized_gas: z.number(),
+            max_refine_gas: z.number(),
+            block_gas_limit: z.number(),
+            recent_block_count: z.number(),
+            max_work_items: z.number(),
+            max_dependencies: z.number(),
+            max_tickets_per_block: z.number(),
+            max_lookup_anchor_age: z.number(),
+            tickets_attempts_number: z.number(),
+            auth_window: z.number(),
+            auth_queue_len: z.number(),
+            rotation_period: z.number(),
+            max_extrinsics: z.number(),
+            availability_timeout: z.number(),
+            val_count: z.number(),
+            max_input: z.number(),
+            max_refine_code_size: z.number(),
+            basic_piece_len: z.number(),
+            max_imports: z.number(),
+            max_is_authorized_code_size: z.number(),
+            max_exports: z.number(),
+            max_refine_memory: z.number(),
+            max_is_authorized_memory: z.number(),
+            segment_piece_count: z.number(),
+            max_report_elective_data: z.number(),
+            transfer_memo_size: z.number(),
+            epoch_tail_start: z.number(),
+            core_count: z.number(),
+            slot_period_sec: z.number(),
+            max_authorizer_code_size: z.number(),
+            max_service_code_size: z.number(),
+        }),
+    });
+    validation.notImplementedSchema = {
+        input: z.tuple([]),
+        output: z.any(),
+    };
+    validation.unsubscribeSchema = {
+        input: z.tuple([z.string()]),
+        output: z.boolean(),
+    };
+    validation.schemas = {
+        beefyRoot: validation.notImplementedSchema,
+        submitPreimage: validation.notImplementedSchema,
+        submitWorkPackage: validation.notImplementedSchema,
+        workReport: validation.notImplementedSchema,
+        submitWorkPackageBundle: validation.notImplementedSchema,
+        workPackageStatus: validation.notImplementedSchema,
+        subscribeWorkPackageStatus: validation.notImplementedSchema,
+        fetchWorkPackageSegments: validation.notImplementedSchema,
+        fetchSegments: validation.notImplementedSchema,
+        syncState: validation.notImplementedSchema,
+        subscribeSyncStatus: validation.notImplementedSchema,
+        bestBlock: {
+            input: validation.noArgs,
+            output: validation.blockDescriptor,
+        },
+        finalizedBlock: {
+            input: validation.noArgs,
+            output: validation.blockDescriptor,
+        },
+        listServices: {
+            input: z.tuple([validation.hash]),
+            output: z.array(validation.serviceId),
+        },
+        parameters: {
+            input: validation.noArgs,
+            output: validation.parameters,
+        },
+        parent: {
+            input: z.tuple([validation.hash]),
+            output: validation.blockDescriptor,
+        },
+        serviceData: {
+            input: z.tuple([validation.hash, validation.serviceId]),
+            output: z.union([validation.blobArray, z.null()]),
+        },
+        servicePreimage: {
+            input: z.tuple([validation.hash, validation.serviceId, validation.hash]),
+            output: z.union([validation.blobArray, z.null()]),
+        },
+        serviceRequest: {
+            input: z.tuple([validation.hash, validation.serviceId, validation.hash, validation.preimageLength]),
+            output: z.union([z.array(validation.slot).readonly(), z.null()]),
+        },
+        serviceValue: {
+            input: z.tuple([validation.hash, validation.serviceId, validation.blobArray]),
+            output: z.union([validation.blobArray, z.null()]),
+        },
+        stateRoot: {
+            input: z.tuple([validation.hash]),
+            output: validation.hash,
+        },
+        statistics: {
+            input: z.tuple([validation.hash]),
+            output: validation.blobArray,
+        },
+        subscribeBestBlock: {
+            input: validation.noArgs,
+            output: z.string(),
+        },
+        subscribeFinalizedBlock: {
+            input: validation.noArgs,
+            output: z.string(),
+        },
+        subscribeServiceData: {
+            input: z.tuple([validation.serviceId, z.boolean()]),
+            output: z.string(),
+        },
+        subscribeServicePreimage: {
+            input: z.tuple([validation.serviceId, validation.hash, z.boolean()]),
+            output: z.string(),
+        },
+        subscribeServiceRequest: {
+            input: z.tuple([validation.serviceId, validation.hash, validation.preimageLength, z.boolean()]),
+            output: z.string(),
+        },
+        subscribeServiceValue: {
+            input: z.tuple([validation.serviceId, validation.blobArray, z.boolean()]),
+            output: z.string(),
+        },
+        subscribeStatistics: {
+            input: z.tuple([z.boolean()]),
+            output: z.string(),
+        },
+        unsubscribeBestBlock: validation.unsubscribeSchema,
+        unsubscribeFinalizedBlock: validation.unsubscribeSchema,
+        unsubscribeServiceData: validation.unsubscribeSchema,
+        unsubscribeServicePreimage: validation.unsubscribeSchema,
+        unsubscribeServiceRequest: validation.unsubscribeSchema,
+        unsubscribeServiceValue: validation.unsubscribeSchema,
+        unsubscribeStatistics: validation.unsubscribeSchema,
+    };
+    validation.jsonRpcRequest = z.object({
+        jsonrpc: z.literal(JSON_RPC_VERSION),
+        method: z.string(),
+        params: z.unknown().optional(),
+        id: z.union([z.string(), z.number(), z.null()]),
+    });
+    validation.jsonRpcNotification = validation.jsonRpcRequest.omit({ id: true });
+})(validation || (validation = {}));
+export const SUBSCRIBABLE_METHODS = {
+    subscribeBestBlock: "unsubscribeBestBlock",
+    subscribeFinalizedBlock: "unsubscribeFinalizedBlock",
+    subscribeServiceData: "unsubscribeServiceData",
+    subscribeServicePreimage: "unsubscribeServicePreimage",
+    subscribeServiceRequest: "unsubscribeServiceRequest",
+    subscribeServiceValue: "unsubscribeServiceValue",
+    subscribeStatistics: "unsubscribeStatistics",
+};

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

@@ -0,0 +1,26 @@
+import type { EntropyHash } from "#@typeberry/block";
+import type { SignedTicket } from "#@typeberry/block/tickets.js";
+import { BytesBlob } from "#@typeberry/bytes";
+import type { BandersnatchKey, BandersnatchSecretSeed } from "#@typeberry/crypto";
+import { type BandersnatchRingRoot, type BandersnatchVrfSignature } from "#@typeberry/crypto/bandersnatch.js";
+import { type OpaqueHash } from "#@typeberry/hash";
+import { type Opaque, Result } from "#@typeberry/utils";
+import type { BandernsatchWasm } from "./bandersnatch-wasm.js";
+declare const FUNCTIONS: {
+    verifySeal: typeof verifySeal;
+    verifyTickets: typeof verifyTickets;
+    getRingCommitment: typeof getRingCommitment;
+    generateSeal: typeof generateSeal;
+    getVrfOutputHash: typeof getVrfOutputHash;
+};
+export default FUNCTIONS;
+declare function verifySeal(bandersnatch: BandernsatchWasm, authorKey: BandersnatchKey, signature: BandersnatchVrfSignature, payload: BytesBlob, encodedUnsealedHeader: BytesBlob): Promise<Result<EntropyHash, null>>;
+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;
+}[]>;
+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>>;
+//# sourceMappingURL=bandersnatch-vrf.d.ts.map

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

@@ -0,0 +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,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAGL,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;;;;;;CAMd,CAAC;AAKF,eAAe,SAAS,CAAC;AAEzB,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"}

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

@@ -0,0 +1,90 @@
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { BANDERSNATCH_RING_ROOT_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, } from "#@typeberry/crypto/bandersnatch.js";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Result } from "#@typeberry/utils";
+import { JAM_TICKET_SEAL } from "./constants.js";
+const RESULT_INDEX = 0;
+var ResultValues;
+(function (ResultValues) {
+    ResultValues[ResultValues["Ok"] = 0] = "Ok";
+    ResultValues[ResultValues["Error"] = 1] = "Error";
+})(ResultValues || (ResultValues = {}));
+/**
+ * Getting a ring commitment is pretty expensive (hundreds of ms),
+ * yet the validators do not always change.
+ * For current benchmarks, we get a huge hit every epoch, hence
+ * 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.
+ */
+const ringCommitmentCache = [];
+const FUNCTIONS = {
+    verifySeal,
+    verifyTickets,
+    getRingCommitment,
+    generateSeal,
+    getVrfOutputHash,
+};
+// NOTE [ToDr] We export the entire object to allow mocking in tests.
+// Ideally we would just export functions and figure out how to mock
+// properly in ESM.
+export default FUNCTIONS;
+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.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({
+        keys,
+        value,
+    });
+    if (ringCommitmentCache.length > MAX_CACHE_ENTRIES) {
+        ringCommitmentCache.shift();
+    }
+    return value;
+}
+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.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(),
+    }));
+}
+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.ok(Bytes.fromBlob(result.subarray(1), BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque());
+}
+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.ok(Bytes.fromBlob(result.subarray(1), HASH_SIZE).asOpaque());
+}

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

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

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

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

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

@@ -0,0 +1,158 @@
+import assert, { deepEqual } from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsValidatorIndex } from "#@typeberry/block";
+import { tryAsTicketAttempt } from "#@typeberry/block/tickets.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { asKnownSize } from "#@typeberry/collections";
+import { BANDERSNATCH_KEY_BYTES, SEED_SIZE } from "#@typeberry/crypto";
+import { BANDERSNATCH_PROOF_BYTES, BANDERSNATCH_RING_ROOT_BYTES, BANDERSNATCH_VRF_SIGNATURE_BYTES, } from "#@typeberry/crypto/bandersnatch.js";
+import { deriveBandersnatchPublicKey } from "#@typeberry/crypto/key-derivation.js";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Result } from "#@typeberry/utils";
+import bandersnatchVrf from "./bandersnatch-vrf.js";
+import { BandernsatchWasm } from "./bandersnatch-wasm.js";
+const bandersnatchWasm = BandernsatchWasm.new();
+const attempt = (v) => tryAsTicketAttempt(v);
+describe("Bandersnatch verification", () => {
+    describe("getRingCommitment", () => {
+        const bandersnatchKeys = asKnownSize([
+            "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+            "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+            "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+            "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+            "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+            "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+        ].map((x) => Bytes.parseBytes(x, BANDERSNATCH_KEY_BYTES).asOpaque()));
+        it("should return commitment", async () => {
+            const result = await bandersnatchVrf.getRingCommitment(await bandersnatchWasm, bandersnatchKeys);
+            const expectedCommitment = Bytes.parseBytes("0x8387a131593447e4e1c3d4e220c322e42d33207fa77cd0fedb39fc3491479ca47a2d82295252e278fa3eec78185982ed82ae0c8fd691335e703d663fb5be02b3def15380789320636b2479beab5a03ccb3f0909ffea59d859fcdc7e187e45a8c92e630ae2b14e758ab0960e372172203f4c9a41777dadd529971d7ab9d23ab29fe0e9c85ec450505dde7f5ac038274cf", BANDERSNATCH_RING_ROOT_BYTES);
+            assert.strictEqual(result.isOk, true);
+            assert.deepStrictEqual(result.ok, expectedCommitment);
+        });
+    });
+    describe("verifyTickets", () => {
+        const bandersnatchKeys = [
+            "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+            "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+            "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+            "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+            "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+            "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+        ].map((x) => Bytes.parseBytes(x, BANDERSNATCH_KEY_BYTES).asOpaque());
+        let commitment;
+        before(async () => {
+            const res = await bandersnatchVrf.getRingCommitment(await bandersnatchWasm, bandersnatchKeys);
+            if (res.isOk) {
+                commitment = res.ok;
+            }
+            else {
+                throw new Error("Unable to calculate ring commitment.");
+            }
+        });
+        it("should confirm that all tickets are valid and return correct ids", async () => {
+            const tickets = [
+                {
+                    attempt: attempt(1),
+                    signature: Bytes.parseBytes("0xb342bf8f6fa69c745daad2e99c92929b1da2b840f67e5e8015ac22dd1076343e836fc9d73929ef048dcc6496781c6780d127dd8ce3f1e0289c5c4e95afffc8d4a1586aba841ebfdb721ca86e55847036bc84f19a256dbd7a61a362fb088a4b942b566c14a7f8643a5d976ced0a18d12e32c660d59c66c271332138269cb0fe9c591182e7913ec0bbcf2290d9d68ac9d119ae78a52c0655f4f999e9e83a1c3218f65a0318ade1a5cf1d83d4448a06f856b9956a6910da242a5aaa5bcfc8ba3c05b0341a1868fc476a0d6da019b5f2b4e521903b00e937f23b17ea49d6928c615841da5442e5b070079af6cdbbaed964a9b044dcf1ae69ce2e2febec37f6369910a0b20b9dce71b4cd3396e44a90a0a4c404cb170d7ffd2c5467f152bd5daf40b38e3eecc96d13d4c8924740c14e5622b967dc587f10815bde3afe133987852e4e8a41f3501774e7d32f1014c9f0b6162bb332b36043172504aacc83bf6b13fd6018422dc207d58ca1fad63960626ea4eec25932e0b5b23b33c805603523b1f6d11ebc368b87cae1086ac609f862ac0fdab69123cbe8cfe54d45db437a87aad21ec551c394a220be6ef2fb8363352ceaf5a1a71e0b3088a6d65262c13272ac3f6313bb8cec5018414d3fd90dd15df0d56a1f0d0081e7a2abadbdde7efed75c333d4dfa93e8c3c34788a4f526e907483ac69cd7e87f11d373deaf88cf96c7e98068998e1803493a905974b1dbfb6ef38fd5785c6ca5497d21a9046790b04869fa6166067f9860e6de6f566f99ee0f3b4f4d8516c016da65dc429472ec273f7c63553cc1af565824bd9b60841be0a41988bc2ba0757166b68ee928af74d377e9ce6b98d6d6e63f6c2f8c898882fac87025bcee0451c2fea036cff1e9e7186eea4160262e6cabfac77230cd4fc7dc1ba5b025b74081c135b7b47470bc8380b2e13e6b0575b73d86de1f948e4daf8600206e0485d5b468f335f440c574213f98f4099797bd606e11e4f2d48aa5bbda17decd01077655acf756c526fe12a0153b5bd26896ae41b16479d00883649f6044631161d5b454aa4c1bc7be0acb0c82ffb98734f8c7760b930414758e1597b36e1caf71", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+                {
+                    attempt: attempt(2),
+                    signature: Bytes.parseBytes("0x9ddee7bb67268130bbb23889b327e662cbe832884e203148ba9b1e15539702d11dc971f7f7ff10289130f68ce42cc70e3657d35edab1e552bc68da53008d1f58e24d90fdf1a5d78204c2c32333147976c124725b87ec1861e1ebd6252f79dc6c891567467d39221b6110f5cb2ba389dba903af3fde624596f845202fcc4c96e6bca7537d37b5898ef0a90a916658fb17e2cca588b7b6e96816d8683fe5028c09fc0b8cbedc791c83eab0a39434f1007d4dab587dbfc172e7d4852e5cac6810188c521baa47ff355a99a28380d06f16b4aa3b51aac66b8a6d7bc4454b8d0f676d837caf35f2ab3c4b9ec8cd0e8fadd16e8d6db123d2815dbfa6cbe74866ed9855eecbbab8e2011f84f71a2e360caeac3bcd64c4b46b11ca167e238cf5f0ccfe7f86e27d7eefac788236c548592c6d2c64c12793657caa701d418926fd952e7ba6c211a8f593b38e81f775b16be47e2f76904b5504dfbe5d64c1bcee3180f6d1cf1fc2c597f08afb1bc5213492bd9c84060ce3cb8d531e463078bac747cd66ec326e8e0171ce5d048c3839379ab96ef988130d639a15b9a76946400de42062563441394ec1f6d7f7ce90b7231325015c3f550096537c2ae86f3c774ca4265bd745b2e7365bd9478af0c389467cc34615c89cf8ff337a88d3cd2b2e1f411f714369668f0b4fa2dbb0de3c526e3a9649e82d772dc8de2259be43e3ef7508b5caeb5d57b91eaf140f89f73a57101455a87edeb10374c30a7f2b73df7b2c70c8079f415425bf10597154980bb2cc5fc209167f3b76a305d3bdc3cf6674d95c64e64734fe5af78b235945008072bcd4ae5b605bdd10ba145db56850dab84140dbb0875baba0bf1966ce71ef19770031724a2bce508498a4ff485b3089ac415c8d78dcc6ec9c02a51227875fba7bc16475de074759fa210a2723d21e5aaa0abf5eec706fc8e323c82d7aab7ed3dec320ca15aa1783707f520169ac77adaef95e7ce853b376c1b9e6425d01992fc8fc65d5e49ad47d3ba105094d37c291a287e42d37ce15873ebcb3fbc342ede527e47aea9736914f6e4b8acfa408487d5959352ac9ed48fbf01386c5db0300a7fa5b16aa4942d1", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+                {
+                    attempt: attempt(1),
+                    signature: Bytes.parseBytes("0x8e6eb88b02110c941451eef7da84e65bafaefcec1b1a5640ad579425e4a7e3ee629acf997108156a85e1f0b997be2ee140978aba66ff4f2037d125cfe2b8bb31984080018d9bab2ecf702a629d32dd442d3ef6f0568389ca36ebc699d24011b9a8b4b304c09306a65e8720633d53bfa3f663bb2c0c53fbb12131828de1c53ce37ad624df3fb2a48c5a533ed2f907a6fda011dcd0f93981facebf6b0f48a5da148b5061761363060cffb83713721596b82821808d873818cb43d9caec7667ce18948c0ac0e7c8105139b896fd31b08747cbd53175bce1bf2e6802ee47c2e71a3615e16a6d12c0066c7b9d99db4daaa3fa8d6db123d2815dbfa6cbe74866ed9855eecbbab8e2011f84f71a2e360caeac3bcd64c4b46b11ca167e238cf5f0ccfe7fb84d49b1a744fd616eb13c737a9a192112618b47c75b4c5262b7e928daa8a0e53d5555364d6c89c57753b7d30c66f0af8109ca1a8ccdab84786b78f5e2e8bed078cd7f7e06a47c5e30034b55e76c876106071eac3283a693fb014640066f66ac766c75da8daee2253be28f3041883f2916f91694f35b8b030ff94e9492ddeb444777451524cb37e30028b1397e02812b9212fa3d27aedff0e463add1f247b64641984ec591cebffa09c349db15ddc301417de26dc9929d53b38f2e52f720fa1144f99f07b64e1df45313bdb4dcf5335ab22ffabe239c818460b8393bbb8e8273b346b95633a20b0b953f7c2081776617126a340c16cc769008897d87f69a250688a980f00fcd8360b4d85557425cabdbe3e4e15ab05ebf250750b7a05959cb16f78613cc1b3388b0f1cb5f0837f8cafb7ec2a7bb1c17043caf5504e9406dbd0eae87b61acc0c948d0f64ac0262933ed5bdd5bb44423a82f7dcf0e0b9ed08948ed7eebd71f19879321bb7c36fa0520b464d061f623b83eec704ae9d7df50658af0b64c9116471641555ed7986a29f08348e51554f5394e83e98d7301a6cb29e291d2b93c3e2ef8fe89f9d33c88da7d731e7b62ffdfa392516b51c1086e9c1a3a794b5228dfdf4a26eab4c6e4104b43997c469de2e814af0ba14954ebafb8a05bf799a33b9fe4a6a1abde66e3263ab6557", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+            ];
+            const entropy = Bytes.parseBytes("0xbb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa", HASH_SIZE).asOpaque();
+            const expectedIds = [
+                "0x09a696b142112c0af1cd2b5f91726f2c050112078e3ef733198c5f43daa20d2b",
+                "0x13fecb426e0a73b84b58b9a0832b11582dc971e79c5399e69f0baf1a244c7787",
+                "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), expectedIds);
+        });
+        it("should detect that one signature is incorrect", async () => {
+            const tickets = [
+                {
+                    attempt: attempt(1),
+                    signature: Bytes.parseBytes("0x9ddee7bb67268130bbb23889b327e662cbe832884e203148ba9b1e15539702d11dc971f7f7ff10289130f68ce42cc70e3657d35edab1e552bc68da53008d1f58e24d90fdf1a5d78204c2c32333147976c124725b87ec1861e1ebd6252f79dc6c891567467d39221b6110f5cb2ba389dba903af3fde624596f845202fcc4c96e6bca7537d37b5898ef0a90a916658fb17e2cca588b7b6e96816d8683fe5028c09fc0b8cbedc791c83eab0a39434f1007d4dab587dbfc172e7d4852e5cac6810188c521baa47ff355a99a28380d06f16b4aa3b51aac66b8a6d7bc4454b8d0f676d837caf35f2ab3c4b9ec8cd0e8fadd16e8d6db123d2815dbfa6cbe74866ed9855eecbbab8e2011f84f71a2e360caeac3bcd64c4b46b11ca167e238cf5f0ccfe7f86e27d7eefac788236c548592c6d2c64c12793657caa701d418926fd952e7ba6c211a8f593b38e81f775b16be47e2f76904b5504dfbe5d64c1bcee3180f6d1cf1fc2c597f08afb1bc5213492bd9c84060ce3cb8d531e463078bac747cd66ec326e8e0171ce5d048c3839379ab96ef988130d639a15b9a76946400de42062563441394ec1f6d7f7ce90b7231325015c3f550096537c2ae86f3c774ca4265bd745b2e7365bd9478af0c389467cc34615c89cf8ff337a88d3cd2b2e1f411f714369668f0b4fa2dbb0de3c526e3a9649e82d772dc8de2259be43e3ef7508b5caeb5d57b91eaf140f89f73a57101455a87edeb10374c30a7f2b73df7b2c70c8079f415425bf10597154980bb2cc5fc209167f3b76a305d3bdc3cf6674d95c64e64734fe5af78b235945008072bcd4ae5b605bdd10ba145db56850dab84140dbb0875baba0bf1966ce71ef19770031724a2bce508498a4ff485b3089ac415c8d78dcc6ec9c02a51227875fba7bc16475de074759fa210a2723d21e5aaa0abf5eec706fc8e323c82d7aab7ed3dec320ca15aa1783707f520169ac77adaef95e7ce853b376c1b9e6425d01992fc8fc65d5e49ad47d3ba105094d37c291a287e42d37ce15873ebcb3fbc342ede527e47aea9736914f6e4b8acfa408487d5959352ac9ed48fbf01386c5db0300a7fa5b16aa4942d1", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+                {
+                    attempt: attempt(2),
+                    signature: Bytes.parseBytes("0x9ddee7bb67268130bbb23889b327e662cbe832884e203148ba9b1e15539702d11dc971f7f7ff10289130f68ce42cc70e3657d35edab1e552bc68da53008d1f58e24d90fdf1a5d78204c2c32333147976c124725b87ec1861e1ebd6252f79dc6c891567467d39221b6110f5cb2ba389dba903af3fde624596f845202fcc4c96e6bca7537d37b5898ef0a90a916658fb17e2cca588b7b6e96816d8683fe5028c09fc0b8cbedc791c83eab0a39434f1007d4dab587dbfc172e7d4852e5cac6810188c521baa47ff355a99a28380d06f16b4aa3b51aac66b8a6d7bc4454b8d0f676d837caf35f2ab3c4b9ec8cd0e8fadd16e8d6db123d2815dbfa6cbe74866ed9855eecbbab8e2011f84f71a2e360caeac3bcd64c4b46b11ca167e238cf5f0ccfe7f86e27d7eefac788236c548592c6d2c64c12793657caa701d418926fd952e7ba6c211a8f593b38e81f775b16be47e2f76904b5504dfbe5d64c1bcee3180f6d1cf1fc2c597f08afb1bc5213492bd9c84060ce3cb8d531e463078bac747cd66ec326e8e0171ce5d048c3839379ab96ef988130d639a15b9a76946400de42062563441394ec1f6d7f7ce90b7231325015c3f550096537c2ae86f3c774ca4265bd745b2e7365bd9478af0c389467cc34615c89cf8ff337a88d3cd2b2e1f411f714369668f0b4fa2dbb0de3c526e3a9649e82d772dc8de2259be43e3ef7508b5caeb5d57b91eaf140f89f73a57101455a87edeb10374c30a7f2b73df7b2c70c8079f415425bf10597154980bb2cc5fc209167f3b76a305d3bdc3cf6674d95c64e64734fe5af78b235945008072bcd4ae5b605bdd10ba145db56850dab84140dbb0875baba0bf1966ce71ef19770031724a2bce508498a4ff485b3089ac415c8d78dcc6ec9c02a51227875fba7bc16475de074759fa210a2723d21e5aaa0abf5eec706fc8e323c82d7aab7ed3dec320ca15aa1783707f520169ac77adaef95e7ce853b376c1b9e6425d01992fc8fc65d5e49ad47d3ba105094d37c291a287e42d37ce15873ebcb3fbc342ede527e47aea9736914f6e4b8acfa408487d5959352ac9ed48fbf01386c5db0300a7fa5b16aa4942d1", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+                {
+                    attempt: attempt(1),
+                    signature: Bytes.parseBytes("0x8e6eb88b02110c941451eef7da84e65bafaefcec1b1a5640ad579425e4a7e3ee629acf997108156a85e1f0b997be2ee140978aba66ff4f2037d125cfe2b8bb31984080018d9bab2ecf702a629d32dd442d3ef6f0568389ca36ebc699d24011b9a8b4b304c09306a65e8720633d53bfa3f663bb2c0c53fbb12131828de1c53ce37ad624df3fb2a48c5a533ed2f907a6fda011dcd0f93981facebf6b0f48a5da148b5061761363060cffb83713721596b82821808d873818cb43d9caec7667ce18948c0ac0e7c8105139b896fd31b08747cbd53175bce1bf2e6802ee47c2e71a3615e16a6d12c0066c7b9d99db4daaa3fa8d6db123d2815dbfa6cbe74866ed9855eecbbab8e2011f84f71a2e360caeac3bcd64c4b46b11ca167e238cf5f0ccfe7fb84d49b1a744fd616eb13c737a9a192112618b47c75b4c5262b7e928daa8a0e53d5555364d6c89c57753b7d30c66f0af8109ca1a8ccdab84786b78f5e2e8bed078cd7f7e06a47c5e30034b55e76c876106071eac3283a693fb014640066f66ac766c75da8daee2253be28f3041883f2916f91694f35b8b030ff94e9492ddeb444777451524cb37e30028b1397e02812b9212fa3d27aedff0e463add1f247b64641984ec591cebffa09c349db15ddc301417de26dc9929d53b38f2e52f720fa1144f99f07b64e1df45313bdb4dcf5335ab22ffabe239c818460b8393bbb8e8273b346b95633a20b0b953f7c2081776617126a340c16cc769008897d87f69a250688a980f00fcd8360b4d85557425cabdbe3e4e15ab05ebf250750b7a05959cb16f78613cc1b3388b0f1cb5f0837f8cafb7ec2a7bb1c17043caf5504e9406dbd0eae87b61acc0c948d0f64ac0262933ed5bdd5bb44423a82f7dcf0e0b9ed08948ed7eebd71f19879321bb7c36fa0520b464d061f623b83eec704ae9d7df50658af0b64c9116471641555ed7986a29f08348e51554f5394e83e98d7301a6cb29e291d2b93c3e2ef8fe89f9d33c88da7d731e7b62ffdfa392516b51c1086e9c1a3a794b5228dfdf4a26eab4c6e4104b43997c469de2e814af0ba14954ebafb8a05bf799a33b9fe4a6a1abde66e3263ab6557", BANDERSNATCH_PROOF_BYTES).asOpaque(),
+                },
+            ];
+            const entropy = Bytes.parseBytes("0xbb30a42c1e62f0afda5f0a4e8a562f7a13a24cea00ee81917b86b89e801314aa", HASH_SIZE).asOpaque();
+            const expectedIds = [
+                "0x0000000000000000000000000000000000000000000000000000000000000000",
+                "0x13fecb426e0a73b84b58b9a0832b11582dc971e79c5399e69f0baf1a244c7787",
+                "0x3a5d10abc80dda33fe3f40b3bb2e3eefd3e97dda3d617a860c9d94eb70b832ad",
+            ].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), expectedIds);
+        });
+    });
+    describe("verifySeal", () => {
+        const keys = BytesBlob.parseBlob("0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0aa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e3348e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3f16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d");
+        const authorIndex = tryAsValidatorIndex(4);
+        it("should verify seal with some aux data", async () => {
+            const signature = BytesBlob.parseBlob("0xa060e079fdeefc27d1278b9a3d1922874c87e8d0dc7885d08443a29a460af82701bf291885c3c1d84f439688abb435ab1c5cf29baaa1cff157d2731ee748a005032620b6bdc3282b7dd8c54d0e71ad8577cdda0736841cff87394c4ab52d610e");
+            const payload = BytesBlob.parseBlob("0x6a616d5f66616c6c6261636b5f7365616cd2d34655ebcad804c56d2fd5f932c575b6a5dbb3f5652c5202bcc75ab9c2cc95");
+            const auxData = BytesBlob.parseBlob("0x476243ad7cc4fc49cb6cb362c6568e931731d8650d917007a6037cceedd6224499f227c2137bc71b415c18e4eb74c6450e575af3708d52cb40ea15dee1ce574a189d15af832dfe4f67744008b62c334b569fcbb4c261e0f065655697306ca2520c000000016f6ad2224d7d58aec6573c623ab110700eaca20a48dc2965d535e466d524af2a835ac82bfa2ce8390bb50680d4b7a73dfa2a4cff6d8c30694b24a605f9574eaf5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0aa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e3348e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3f16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d000004004b213bfc74f65eb109896f1d57e78809d1a94c0c1b2e4543a9ee470eb6cfdfee96228bd01847dbe9e92c5c8c190fab85da4cb5ecd63cd3c758730b17b1247d1be6a5107ff246b08fbf8dcad39ba00b33e9ee4e2b934f62ee7e503e2a1eeaba11");
+            const result = await (await bandersnatchWasm).verifySeal(Array.from(keys.chunks(BANDERSNATCH_KEY_BYTES))[authorIndex].raw, signature.raw, payload.raw, auxData.raw);
+            assert.deepStrictEqual(BytesBlob.blobFrom(result).toString(), "0x001286e739f65659311c7f3380ec9afad3560bc2971a0ea1d0acc961d79c0cf4c4");
+        });
+        it("should verify seal without aux data", async () => {
+            const signature = BytesBlob.parseBlob("0x4b213bfc74f65eb109896f1d57e78809d1a94c0c1b2e4543a9ee470eb6cfdfee96228bd01847dbe9e92c5c8c190fab85da4cb5ecd63cd3c758730b17b1247d1be6a5107ff246b08fbf8dcad39ba00b33e9ee4e2b934f62ee7e503e2a1eeaba11");
+            const payload = BytesBlob.parseBlob("0x6a616d5f656e74726f70791286e739f65659311c7f3380ec9afad3560bc2971a0ea1d0acc961d79c0cf4c4");
+            const auxData = BytesBlob.parseBlob("0x");
+            const result = await (await bandersnatchWasm).verifySeal(Array.from(keys.chunks(BANDERSNATCH_KEY_BYTES))[authorIndex].raw, signature.raw, payload.raw, auxData.raw);
+            assert.deepStrictEqual(BytesBlob.blobFrom(result).toString(), "0x00543054132a05c2710ac8fd0924810d3a8f7b7a7637c31a35cf6a05d54122529f");
+        });
+    });
+    describe("generateSeal", () => {
+        it("should generate a valid seal", async () => {
+            const secretSeed = Bytes.fill(SEED_SIZE, 1).asOpaque();
+            const input = BytesBlob.blobFromString("example input");
+            const auxData = BytesBlob.blobFromString("example aux data");
+            const expectedSeal = Bytes.parseBytes("0x0b6c772fe61e4e7252722633475c998be3bfcabcda2efff75edaa7c6c889f4df8b487dea89dfbdf086e74c7a3678fed15e5b39eceebf133711c7410ea99d420163f50a95249c087272604395fc694a522ac50a572ac66a4706366a69fda74500", BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque();
+            const result = await bandersnatchVrf.generateSeal(await bandersnatchWasm, secretSeed, input, auxData);
+            deepEqual(result, Result.ok(expectedSeal));
+        });
+        it("should generate two seals that are the same on first 32 bytes", async () => {
+            const secretSeed = Bytes.fill(SEED_SIZE, 1).asOpaque();
+            const input = BytesBlob.blobFromString("example input");
+            const auxData1 = BytesBlob.blobFromString("example aux data1");
+            const auxData2 = BytesBlob.blobFromString("example aux data2");
+            const result1 = await bandersnatchVrf.generateSeal(await bandersnatchWasm, secretSeed, input, auxData1);
+            const result2 = await bandersnatchVrf.generateSeal(await bandersnatchWasm, secretSeed, input, auxData2);
+            if (result1.isError || result2.isError) {
+                throw new Error("Seal generation failed");
+            }
+            deepEqual(BytesBlob.blobFrom(result1.ok.raw.subarray(0, HASH_SIZE)), BytesBlob.blobFrom(result2.ok.raw.subarray(0, HASH_SIZE)));
+            assert.notDeepEqual(result1.ok, result2.ok);
+        });
+        it("should generate and verify seal", async () => {
+            const secretSeed = Bytes.fill(SEED_SIZE, 1).asOpaque();
+            const pubKey = deriveBandersnatchPublicKey(secretSeed);
+            const input = BytesBlob.blobFromString("example input");
+            const auxData = BytesBlob.blobFromString("example aux data");
+            const expectedSeal = Bytes.parseBytes("0x0b6c772fe61e4e7252722633475c998be3bfcabcda2efff75edaa7c6c889f4df8b487dea89dfbdf086e74c7a3678fed15e5b39eceebf133711c7410ea99d420163f50a95249c087272604395fc694a522ac50a572ac66a4706366a69fda74500", BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque();
+            const generationResult = await bandersnatchVrf.generateSeal(await bandersnatchWasm, secretSeed, input, auxData);
+            deepEqual(generationResult, Result.ok(expectedSeal));
+            if (generationResult.isError) {
+                throw new Error("Seal generation failed");
+            }
+            const verificationResult = await bandersnatchVrf.verifySeal(await bandersnatchWasm, pubKey, generationResult.ok, input, auxData);
+            deepEqual(verificationResult, Result.ok(BytesBlob.parseBlob("0x000b0e5c06e70a23d6cfed372763de718b0c21119ea51f7afe1e69b0000de620")));
+        });
+    });
+});

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

@@ -0,0 +1,10 @@
+export declare class BandernsatchWasm {
+    private constructor();
+    static new(): Promise<BandernsatchWasm>;
+    verifySeal(authorKey: Uint8Array, signature: Uint8Array, payload: Uint8Array, auxData: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    getRingCommitment(keys: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    batchVerifyTicket(ringSize: number, commitment: Uint8Array, ticketsData: Uint8Array, contextLength: number): Promise<Uint8Array<ArrayBufferLike>>;
+    generateSeal(authorKey: Uint8Array, input: Uint8Array, auxData: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    getVrfOutputHash(authorKey: Uint8Array, input: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+}
+//# sourceMappingURL=bandersnatch-wasm.d.ts.map

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

@@ -0,0 +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,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;CAGhE"}

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

@@ -0,0 +1,23 @@
+import { bandersnatchWasm, initWasm } from "#@typeberry/crypto";
+export class BandernsatchWasm {
+    constructor() { }
+    static async new() {
+        await initWasm();
+        return new BandernsatchWasm();
+    }
+    async verifySeal(authorKey, signature, payload, auxData) {
+        return bandersnatchWasm.verify_seal(authorKey, signature, payload, auxData);
+    }
+    async getRingCommitment(keys) {
+        return bandersnatchWasm.ring_commitment(keys);
+    }
+    async batchVerifyTicket(ringSize, commitment, ticketsData, contextLength) {
+        return bandersnatchWasm.batch_verify_tickets(ringSize, commitment, ticketsData, contextLength);
+    }
+    async generateSeal(authorKey, input, auxData) {
+        return bandersnatchWasm.generate_seal(authorKey, input, auxData);
+    }
+    async getVrfOutputHash(authorKey, input) {
+        return bandersnatchWasm.vrf_output_hash(authorKey, input);
+    }
+}

package/packages/jam/safrole/constants.d.ts

@@ -0,0 +1,7 @@
+/** `X_E`: https://graypaper.fluffylabs.dev/#/68eaa1f/0e90010e9001?v=0.6.4 */
+export declare const JAM_ENTROPY: Uint8Array<ArrayBufferLike>;
+/** `X_F`: https://graypaper.fluffylabs.dev/#/68eaa1f/0ea5010ea501?v=0.6.4 */
+export declare const JAM_FALLBACK_SEAL: Uint8Array<ArrayBufferLike>;
+/** `X_T`: https://graypaper.fluffylabs.dev/#/68eaa1f/0ebc010ebc01?v=0.6.4 */
+export declare const JAM_TICKET_SEAL: Uint8Array<ArrayBufferLike>;
+//# sourceMappingURL=constants.d.ts.map

package/packages/jam/safrole/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/constants.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,eAAO,MAAM,WAAW,6BAA8C,CAAC;AACvE,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,6BAAoD,CAAC;AACnF,6EAA6E;AAC7E,eAAO,MAAM,eAAe,6BAAkD,CAAC"}

package/packages/jam/safrole/constants.js

@@ -0,0 +1,7 @@
+import { BytesBlob } from "#@typeberry/bytes";
+/** `X_E`: https://graypaper.fluffylabs.dev/#/68eaa1f/0e90010e9001?v=0.6.4 */
+export const JAM_ENTROPY = BytesBlob.blobFromString("jam_entropy").raw;
+/** `X_F`: https://graypaper.fluffylabs.dev/#/68eaa1f/0ea5010ea501?v=0.6.4 */
+export const JAM_FALLBACK_SEAL = BytesBlob.blobFromString("jam_fallback_seal").raw;
+/** `X_T`: https://graypaper.fluffylabs.dev/#/68eaa1f/0ebc010ebc01?v=0.6.4 */
+export const JAM_TICKET_SEAL = BytesBlob.blobFromString("jam_ticket_seal").raw;

package/packages/jam/safrole/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./bandersnatch-vrf.js";
+export type { SafroleStateUpdate } from "./safrole.js";
+export { Safrole, SafroleErrorCode, VALIDATOR_META_BYTES } from "./safrole.js";
+export { SafroleSeal } from "./safrole-seal.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/safrole/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/packages/jam/safrole/index.js

@@ -0,0 +1,3 @@
+export * from "./bandersnatch-vrf.js";
+export { Safrole, SafroleErrorCode, VALIDATOR_META_BYTES } from "./safrole.js";
+export { SafroleSeal } from "./safrole-seal.js";

package/packages/jam/safrole/safrole-seal.d.ts

@@ -0,0 +1,31 @@
+import { type EntropyHash, type HeaderView, type PerEpochBlock, type TimeSlot } from "#@typeberry/block";
+import type { Ticket } from "#@typeberry/block/tickets.js";
+import { type BandersnatchKey } from "#@typeberry/crypto";
+import type { State, ValidatorData } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+import { BandernsatchWasm } from "./bandersnatch-wasm.js";
+export declare enum SafroleSealError {
+    InvalidValidatorIndex = 0,
+    InvalidValidator = 1,
+    InvalidTicket = 2,
+    IncorrectSeal = 3,
+    IncorrectEntropySource = 4
+}
+export type SafroleSealState = Pick<State, "currentValidatorData" | "sealingKeySeries"> & {
+    currentEntropy: EntropyHash;
+};
+export declare class SafroleSeal {
+    private readonly bandersnatch;
+    constructor(bandersnatch?: Promise<BandernsatchWasm>);
+    /**
+     * Note the verification needs to be done AFTER the state transition,
+     * hence the state is passed as an argument for more control.
+     */
+    verifyHeaderSeal(headerView: HeaderView, state: SafroleSealState): Promise<Result<EntropyHash, SafroleSealError>>;
+    private verifySeal;
+    /** Regular (non-fallback) mode of Safrole. */
+    verifySealWithTicket(tickets: PerEpochBlock<Ticket>, timeSlot: TimeSlot, entropy: EntropyHash, validatorData: ValidatorData, headerView: HeaderView): Promise<Result<EntropyHash, SafroleSealError>>;
+    /** Fallback mode of Safrole. */
+    verifySealWithKeys(keys: PerEpochBlock<BandersnatchKey>, timeSlot: TimeSlot, entropy: EntropyHash, authorKey: ValidatorData, headerView: HeaderView): Promise<Result<EntropyHash, SafroleSealError>>;
+}
+//# sourceMappingURL=safrole-seal.d.ts.map

package/packages/jam/safrole/safrole-seal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safrole-seal.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/safrole-seal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,oBAAY,gBAAgB;IAC1B,qBAAqB,IAAI;IACzB,gBAAgB,IAAI;IACpB,aAAa,IAAI;IACjB,aAAa,IAAI;IACjB,sBAAsB,IAAI;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,GAAG;IACxF,cAAc,EAAE,WAAW,CAAC;CAC7B,CAAC;AAIF,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,GAAE,OAAO,CAAC,gBAAgB,CAA0B;IAC7F;;;OAGG;IACG,gBAAgB,CACpB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;YA6BnC,UAAU;IA0BxB,8CAA8C;IACxC,oBAAoB,CACxB,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IA4BjD,gCAAgC;IAC1B,kBAAkB,CACtB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,EACpC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;CA2BlD"}