@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/transition/disputes/disputes.test.data2.js

@@ -0,0 +1,189 @@
+// from progress_invalidates_avail_assignments-1.json
+import { tryAsCoreIndex, tryAsPerValidator, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { RefineContext } from "#@typeberry/block/refine-context.js";
+import { WorkPackageSpec, WorkReport } from "#@typeberry/block/work-report.js";
+import { WorkExecResult, WorkExecResultKind, WorkRefineLoad, WorkResult } from "#@typeberry/block/work-result.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { FixedSizeArray } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU8, tryAsU16, tryAsU32 } from "#@typeberry/numbers";
+import { createCulprit, createFault, createValidatorData, createVerdict } from "./disputes.test.data.js";
+export const currentValidatorData = tryAsPerValidator([
+    {
+        bandersnatch: "0xff71c6c03ff88adb5ed52c9681de1629a54e702fc14729f6b50d2f0a76f185b3",
+        ed25519: "0x4418fb8c85bb3985394a8c2756d3643457ce614546202a2f50b093d762499ace",
+    },
+    {
+        bandersnatch: "0xdee6d555b82024f1ccf8a1e37e60fa60fd40b1958c4bb3006af78647950e1b91",
+        ed25519: "0xad93247bd01307550ec7acd757ce6fb805fcf73db364063265b30a949e90d933",
+    },
+    {
+        bandersnatch: "0x9326edb21e5541717fde24ec085000b28709847b8aab1ac51f84e94b37ca1b66",
+        ed25519: "0xcab2b9ff25c2410fbe9b8a717abb298c716a03983c98ceb4def2087500b8e341",
+    },
+    {
+        bandersnatch: "0x0746846d17469fb2f95ef365efcab9f4e22fa1feb53111c995376be8019981cc",
+        ed25519: "0xf30aa5444688b3cab47697b37d5cac5707bb3289e986b19b17db437206931a8d",
+    },
+    {
+        bandersnatch: "0x151e5c8fe2b9d8a606966a79edd2f9e5db47e83947ce368ccba53bf6ba20a40b",
+        ed25519: "0x8b8c5d436f92ecf605421e873a99ec528761eb52a88a2f9a057b3b3003e6f32a",
+    },
+    {
+        bandersnatch: "0x2105650944fcd101621fd5bb3124c9fd191d114b7ad936c1d79d734f9f21392e",
+        ed25519: "0xab0084d01534b31c1dd87c81645fd762482a90027754041ca1b56133d0466c06",
+    },
+].map(createValidatorData), tinyChainSpec);
+export const previousValidatorData = tryAsPerValidator([
+    {
+        bandersnatch: "0x9326edb21e5541717fde24ec085000b28709847b8aab1ac51f84e94b37ca1b66",
+        ed25519: "0xcab2b9ff25c2410fbe9b8a717abb298c716a03983c98ceb4def2087500b8e341",
+    },
+    {
+        bandersnatch: "0x2105650944fcd101621fd5bb3124c9fd191d114b7ad936c1d79d734f9f21392e",
+        ed25519: "0xab0084d01534b31c1dd87c81645fd762482a90027754041ca1b56133d0466c06",
+    },
+    {
+        bandersnatch: "0xff71c6c03ff88adb5ed52c9681de1629a54e702fc14729f6b50d2f0a76f185b3",
+        ed25519: "0x4418fb8c85bb3985394a8c2756d3643457ce614546202a2f50b093d762499ace",
+    },
+    {
+        bandersnatch: "0x151e5c8fe2b9d8a606966a79edd2f9e5db47e83947ce368ccba53bf6ba20a40b",
+        ed25519: "0x8b8c5d436f92ecf605421e873a99ec528761eb52a88a2f9a057b3b3003e6f32a",
+    },
+    {
+        bandersnatch: "0xdee6d555b82024f1ccf8a1e37e60fa60fd40b1958c4bb3006af78647950e1b91",
+        ed25519: "0xad93247bd01307550ec7acd757ce6fb805fcf73db364063265b30a949e90d933",
+    },
+    {
+        bandersnatch: "0x0746846d17469fb2f95ef365efcab9f4e22fa1feb53111c995376be8019981cc",
+        ed25519: "0xf30aa5444688b3cab47697b37d5cac5707bb3289e986b19b17db437206931a8d",
+    },
+].map(createValidatorData), tinyChainSpec);
+export const verdicts = [
+    {
+        target: "0x253a07e4ceacf3541a6b529c5d8089180a226d3acb9d10b9c3026cd2744a893b",
+        age: 0,
+        votes: [
+            {
+                vote: true,
+                index: 0,
+                signature: "0x0b5fdb78578af439d20ac06c8fa59a222c66e31f5d3174d3f3698951d9bd8c150a735604aa54dbf5a1d6a6b5fda4297dbbbee524592a36c504052efdb4fbcb0a",
+            },
+            {
+                vote: true,
+                index: 1,
+                signature: "0xddcd6ca7a180fca910a5d57569d4ac464d43a072311ad9843c7440a0c11a8c0b2ac7c6c1a209479749ed427292ecc484075f5c050b6a287d756f100cb0033e0d",
+            },
+            {
+                vote: true,
+                index: 2,
+                signature: "0xac267be8396a0c9439ed6c4dba397adfdc496c8bf6807b585251a3d9b695e1703a07bf79c7b127a0c190d6b13ebadd5ab6aeb39b5162dbd56f1049f831ae000c",
+            },
+            {
+                vote: true,
+                index: 3,
+                signature: "0x797cb99686ab8ddda3d0ee39afb9e8268d83f77ad315b8034f8ec2ac73e57a74cc5d9becfdb6b7ff52b551f5cfda21035e9e373b1c2f68428d4c530455888606",
+            },
+            {
+                vote: true,
+                index: 4,
+                signature: "0x5a7239242231c3322ef376f99c737893897f273db46746b24f5306970739b0464910fe334fa456b957cc6fda1eac1f97c822368310b81a1fd6405d8a496d380f",
+            },
+        ],
+    },
+    {
+        target: "0xb02d0c733076bb73458333c09682905985c7a0c62ae1f5dcf2e5b7f045f999e2",
+        age: 0,
+        votes: [
+            {
+                vote: false,
+                index: 0,
+                signature: "0x6da825821a51ebb2a299247bd9d96ecd8156c1dac2319dc68b2dd6138c2cfdda0c08683602ef6f7863b7fc552c695dbff1f4da22afaf3be6a7f0970095848805",
+            },
+            {
+                vote: false,
+                index: 1,
+                signature: "0xfa91463cc1143b6ba63fdd6f276a989ee52b5d8e02b286bcc02372a878721ff421a3d97d1bee8749508fba1c633808dd6d68c36f7749973713ae61c543e6cf05",
+            },
+            {
+                vote: false,
+                index: 2,
+                signature: "0xa0137a732ad9d31263ac1b391515cf774b23bb2a6f36ea1283fb8a3c0937e810543ba123162f4310a978a7a485a565fd33d58aa9a9115dbe230e542b3efeef0e",
+            },
+            {
+                vote: false,
+                index: 3,
+                signature: "0xba192030e9425e931628a510c82c2609b12cc2a7b9b720add4a41a6637561097201e5db7fb1e80afb8fd6787f81c25939e3b881f82a2537359882ea8a6649c0b",
+            },
+            {
+                vote: false,
+                index: 4,
+                signature: "0x6e05d3e3ea4e7e17eab6cef96a4ddb360db3d65f3607718852e03932ab3898f667f5741cbb1c372e9d3c1508c66686e1dbee80bac0ba43428653a8ba9a3ddc0c",
+            },
+        ],
+    },
+].map(createVerdict);
+export const culprits = [
+    {
+        target: "0xb02d0c733076bb73458333c09682905985c7a0c62ae1f5dcf2e5b7f045f999e2",
+        key: "0x4418fb8c85bb3985394a8c2756d3643457ce614546202a2f50b093d762499ace",
+        signature: "0x7dd47778df5a92612c2d1965c7b0e34fd7a0c4ad8298646ad67baf68bda9d54bd2f839aaa4e263991eba388e6963ea16eb536709a00257a88201c51bd3956800",
+    },
+    {
+        target: "0xb02d0c733076bb73458333c09682905985c7a0c62ae1f5dcf2e5b7f045f999e2",
+        key: "0xad93247bd01307550ec7acd757ce6fb805fcf73db364063265b30a949e90d933",
+        signature: "0xd7d972345ae1daef5d57dcf3cf5c4f084c58b6d930cae48feae7bfca9c33b0c80468fa3b4162110897cd99248a973a662cd3162504ae3322d2d5ebee0ee8b30d",
+    },
+].map(createCulprit);
+export const faults = [
+    {
+        target: "0x253a07e4ceacf3541a6b529c5d8089180a226d3acb9d10b9c3026cd2744a893b",
+        vote: false,
+        key: "0xf30aa5444688b3cab47697b37d5cac5707bb3289e986b19b17db437206931a8d",
+        signature: "0xac99e7bae95acaaed8c983d5cad35faeffd51b1a23e977d6e4b1c3f24f9585a0960184d42a4bd0d6cc216f88119e69e2c219cedd74ca46b64944307474646e0d",
+    },
+].map(createFault);
+export function workReport(packageHash, coreIndex) {
+    const workPackageSpec = WorkPackageSpec.create({
+        hash: packageHash,
+        length: tryAsU32(0),
+        erasureRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        exportsRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        exportsCount: tryAsU16(0),
+    });
+    const context = RefineContext.create({
+        anchor: Bytes.zero(HASH_SIZE).asOpaque(),
+        stateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        beefyRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        lookupAnchor: Bytes.zero(HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: tryAsTimeSlot(0),
+        prerequisites: [],
+    });
+    return WorkReport.create({
+        workPackageSpec,
+        context,
+        coreIndex: tryAsCoreIndex(coreIndex),
+        authorizerHash: Bytes.zero(HASH_SIZE).asOpaque(),
+        authorizationOutput: BytesBlob.parseBlob("0x030201"),
+        segmentRootLookup: [],
+        results: FixedSizeArray.new([
+            WorkResult.create({
+                serviceId: tryAsServiceId(coreIndex),
+                codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                payloadHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                gas: tryAsServiceGas(42),
+                result: new WorkExecResult(WorkExecResultKind.ok, BytesBlob.parseBlob("0x010203")),
+                load: WorkRefineLoad.create({
+                    gasUsed: tryAsServiceGas(0),
+                    importedSegments: tryAsU32(0),
+                    exportedSegments: tryAsU32(0),
+                    extrinsicSize: tryAsU32(0),
+                    extrinsicCount: tryAsU32(0),
+                }),
+            }),
+        ], tryAsU8(1)),
+        authorizationGasUsed: tryAsServiceGas(0),
+    });
+}

package/packages/jam/transition/disputes/disputes.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsTimeSlot } from "#@typeberry/block";
+import { DisputesExtrinsic } from "#@typeberry/block/disputes.js";
+import { WorkReport } from "#@typeberry/block/work-report.js";
+import { Bytes } from "#@typeberry/bytes";
+import { Encoder } from "#@typeberry/codec";
+import { SortedSet } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { ED25519_KEY_BYTES, initWasm } from "#@typeberry/crypto";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { AvailabilityAssignment, DisputesRecords, hashComparator, tryAsPerCore } from "#@typeberry/state";
+import { resultToString } from "#@typeberry/utils";
+import { Disputes } from "./disputes.js";
+import * as testData from "./disputes.test.data.js";
+import * as testData2 from "./disputes.test.data2.js";
+const createOffender = (blob) => Bytes.parseBytes(blob, ED25519_KEY_BYTES).asOpaque();
+describe("Disputes", () => {
+    let blake2b;
+    before(async () => {
+        await initWasm();
+        blake2b = await Blake2b.createHasher();
+    });
+    const preState = {
+        disputesRecords: DisputesRecords.create({
+            goodSet: SortedSet.fromArray(hashComparator),
+            badSet: SortedSet.fromArray(hashComparator),
+            wonkySet: SortedSet.fromArray(hashComparator),
+            punishSet: SortedSet.fromArray(hashComparator),
+        }),
+        timeslot: tryAsTimeSlot(0),
+        availabilityAssignment: tryAsPerCore([null, null], tinyChainSpec),
+        currentValidatorData: testData.currentValidatorData,
+        previousValidatorData: testData.previousValidatorData,
+    };
+    it("should perform correct state transition and return offenders", async () => {
+        const disputes = new Disputes(tinyChainSpec, blake2b, preState);
+        const { verdicts, culprits, faults } = testData;
+        const disputesExtrinsic = DisputesExtrinsic.create({ verdicts, culprits, faults });
+        const offenders = [
+            "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+            "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+            "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+        ].map(createOffender);
+        const result = await disputes.transition(disputesExtrinsic);
+        const ok = result.isOk ? Array.from(result.ok.offendersMark) : undefined;
+        assert.strictEqual(`${resultToString(result)}`, "OK: [object Object]");
+        assert.deepStrictEqual(ok, offenders);
+    });
+    it("should return incorrect validator index error", async () => {
+        const { verdictsWithIncorrectValidatorIndex, culprits, faults } = testData;
+        const disputes = new Disputes(tinyChainSpec, blake2b, preState);
+        const disputesExtrinsic = DisputesExtrinsic.create({
+            verdicts: verdictsWithIncorrectValidatorIndex,
+            culprits,
+            faults,
+        });
+        const result = await disputes.transition(disputesExtrinsic);
+        const ok = result.isOk ? Array.from(result.ok.offendersMark) : undefined;
+        assert.strictEqual(`${resultToString(result)}`, "Bad validator index in signature verification: 65000\nError: bad_validator_index");
+        assert.strictEqual(ok, undefined);
+    });
+    // NOTE [ToDr] This test is so far disabled for 0.7.0+ because we need
+    // to get the test data for it from w3f test vectors or regenerate the current
+    // data.
+    it.skip("should clear work-reports which were judged as invalid", async () => {
+        const workReport0 = testData2.workReport(Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque(), 0);
+        const workReport1 = testData2.workReport(Bytes.parseBytes("0xe12c22d4f162d9a012c9319233da5d3e923cc5e1029b8f90e47249c9ab256b35", HASH_SIZE).asOpaque(), 1);
+        const workReportHash0 = blake2b.hashBytes(Encoder.encodeObject(WorkReport.Codec, workReport0, tinyChainSpec));
+        assert.strictEqual(`${workReportHash0}`, "0x23dd9ac280cd439a2c04b42cef1f2bbc9abecc7fe6454fecffef59ed110c047d");
+        const workReportHash1 = blake2b.hashBytes(Encoder.encodeObject(WorkReport.Codec, workReport1, tinyChainSpec));
+        assert.strictEqual(`${workReportHash1}`, "0xf00057ba131e973a662509feb0fe6821bf3728860022b3dd9d5543b5bfa6bf8c");
+        const availabilityAssignment1 = AvailabilityAssignment.create({
+            workReport: workReport0,
+            timeout: tryAsTimeSlot(42),
+        });
+        const availabilityAssignment2 = AvailabilityAssignment.create({
+            workReport: workReport1,
+            timeout: tryAsTimeSlot(42),
+        });
+        const { currentValidatorData, previousValidatorData, verdicts, culprits, faults } = testData2;
+        const preStateWithWorkReports = {
+            disputesRecords: DisputesRecords.create({
+                goodSet: SortedSet.fromArray(hashComparator),
+                badSet: SortedSet.fromArray(hashComparator),
+                wonkySet: SortedSet.fromArray(hashComparator),
+                punishSet: SortedSet.fromArray(hashComparator),
+            }),
+            timeslot: tryAsTimeSlot(0),
+            availabilityAssignment: tryAsPerCore([availabilityAssignment1, availabilityAssignment2], tinyChainSpec),
+            currentValidatorData,
+            previousValidatorData,
+        };
+        const disputes = new Disputes(tinyChainSpec, blake2b, preStateWithWorkReports);
+        const disputesExtrinsic = DisputesExtrinsic.create({
+            verdicts,
+            culprits,
+            faults,
+        });
+        const result = await disputes.transition(disputesExtrinsic);
+        const stateUpdate = result.isOk ? result.ok.stateUpdate : undefined;
+        assert.strictEqual(resultToString(result), "OK: [object Object]");
+        assert.notStrictEqual(stateUpdate, undefined);
+        if (stateUpdate !== undefined) {
+            const clearedAvailabilityAssignment = stateUpdate.availabilityAssignment;
+            assert.strictEqual(clearedAvailabilityAssignment[0], null);
+            assert.strictEqual(clearedAvailabilityAssignment[1], availabilityAssignment2);
+        }
+    });
+});

package/packages/jam/transition/disputes/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./disputes.js";
+export * from "./disputes-state.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/transition/disputes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC"}

package/packages/jam/transition/disputes/index.js

@@ -0,0 +1,2 @@
+export * from "./disputes.js";
+export * from "./disputes-state.js";

package/packages/jam/transition/disputes/sort-utils.d.ts

@@ -0,0 +1,11 @@
+import type { Judgement } from "#@typeberry/block/disputes.js";
+import type { BytesBlob } from "#@typeberry/bytes";
+/**
+ * A function that checks if an array of object is ascending sorted by key that is BytesBlob and there is no duplicates
+ */
+export declare function isUniqueSortedBy<T extends Record<K, BytesBlob>, K extends keyof T>(arr: T[], key: K): boolean;
+/**
+ * A function that checks if an array of Judgements is ascending sorted by index and there is no duplicates
+ */
+export declare function isUniqueSortedByIndex(judgements: readonly Judgement[]): boolean;
+//# sourceMappingURL=sort-utils.d.ts.map

package/packages/jam/transition/disputes/sort-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/sort-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,WAQnG;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,WAQrE"}

package/packages/jam/transition/disputes/sort-utils.js

@@ -0,0 +1,22 @@
+/**
+ * A function that checks if an array of object is ascending sorted by key that is BytesBlob and there is no duplicates
+ */
+export function isUniqueSortedBy(arr, key) {
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i - 1][key].compare(arr[i][key]).isGreaterOrEqual()) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * A function that checks if an array of Judgements is ascending sorted by index and there is no duplicates
+ */
+export function isUniqueSortedByIndex(judgements) {
+    for (let i = 1; i < judgements.length; i++) {
+        if (judgements[i - 1].index >= judgements[i].index) {
+            return false;
+        }
+    }
+    return true;
+}

package/packages/jam/transition/disputes/sort-utils.test.d.ts

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

package/packages/jam/transition/disputes/sort-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-utils.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/sort-utils.test.ts"],"names":[],"mappings":""}

package/packages/jam/transition/disputes/sort-utils.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsValidatorIndex } from "#@typeberry/block";
+import { Judgement } from "#@typeberry/block/disputes.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { ED25519_SIGNATURE_BYTES } from "#@typeberry/crypto";
+import { isUniqueSortedBy, isUniqueSortedByIndex } from "./sort-utils.js";
+describe("sort-utils", () => {
+    describe("isUniqueSortedBy", () => {
+        const buildTestData = (key, arrays) => ({
+            data: arrays.map((arr) => ({ [key]: BytesBlob.blobFromNumbers(arr) })),
+            key,
+        });
+        it("should return true for an empty array", () => {
+            const { key, data } = buildTestData("a", []);
+            const result = isUniqueSortedBy(data, key);
+            assert.strictEqual(result, true);
+        });
+        it("should return false in case of the same blobs in array", () => {
+            const { key, data } = buildTestData("a", [
+                [1, 2],
+                [1, 2],
+            ]);
+            const result = isUniqueSortedBy(data, key);
+            assert.strictEqual(result, false);
+        });
+        it("should return false in case of descending order in array", () => {
+            const { key, data } = buildTestData("a", [
+                [2, 1],
+                [1, 2],
+            ]);
+            const result = isUniqueSortedBy(data, key);
+            assert.strictEqual(result, false);
+        });
+        it("should return true in case of ascending order in array", () => {
+            const { key, data } = buildTestData("a", [
+                [1, 2],
+                [2, 1],
+            ]);
+            const result = isUniqueSortedBy(data, key);
+            assert.strictEqual(result, true);
+        });
+    });
+    describe("isUniqueSortedByIndex", () => {
+        const buildTestData = (indices) => indices.map((index) => Judgement.create({
+            isWorkReportValid: true,
+            index: tryAsValidatorIndex(index),
+            signature: Bytes.zero(ED25519_SIGNATURE_BYTES).asOpaque(),
+        }));
+        it("should return true for an empty array", () => {
+            const judgements = buildTestData([]);
+            const result = isUniqueSortedByIndex(judgements);
+            assert.strictEqual(result, true);
+        });
+        it("should return false in case of duplicates in array", () => {
+            const judgements = buildTestData([1, 1]);
+            const result = isUniqueSortedByIndex(judgements);
+            assert.strictEqual(result, false);
+        });
+        it("should return false in case of descending order in array", () => {
+            const judgements = buildTestData([2, 1]);
+            const result = isUniqueSortedByIndex(judgements);
+            assert.strictEqual(result, false);
+        });
+        it("should return true in case of ascending order in array", () => {
+            const judgements = buildTestData([1, 2]);
+            const result = isUniqueSortedByIndex(judgements);
+            assert.strictEqual(result, true);
+        });
+    });
+});

package/packages/jam/transition/disputes/verification-utils.d.ts

@@ -0,0 +1,28 @@
+import type { WorkReportHash } from "#@typeberry/block";
+import type { Culprit, Fault, Judgement } from "#@typeberry/block/disputes.js";
+import { BytesBlob } from "#@typeberry/bytes";
+import { type Ed25519Key, type Ed25519Signature, ed25519 } from "#@typeberry/crypto";
+type InputItem = ed25519.Input<BytesBlob>;
+export type VerificationInput = {
+    judgements: InputItem[];
+    culprits: InputItem[];
+    faults: InputItem[];
+};
+type VerificationResultItem = {
+    signature: Ed25519Signature;
+    isValid: boolean;
+};
+export type VerificationOutput = {
+    judgements: VerificationResultItem[];
+    culprits: VerificationResultItem[];
+    faults: VerificationResultItem[];
+};
+export declare const JAM_VALID: Uint8Array<ArrayBufferLike>;
+export declare const JAM_INVALID: Uint8Array<ArrayBufferLike>;
+export declare const JAM_GUARANTEE: Uint8Array<ArrayBufferLike>;
+export declare function prepareCulpritSignature({ key, signature, workReportHash }: Culprit): InputItem;
+export declare function prepareFaultSignature({ workReportHash, wasConsideredValid, signature, key }: Fault): InputItem;
+export declare function prepareJudgementSignature(judgement: Judgement, workReportHash: WorkReportHash, key: Ed25519Key): InputItem;
+export declare function vefifyAllSignatures(input: VerificationInput): Promise<VerificationOutput>;
+export {};
+//# sourceMappingURL=verification-utils.d.ts.map

package/packages/jam/transition/disputes/verification-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/verification-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,gBAAgB,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEpF,KAAK,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AAE1C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB,CAAC;AACF,KAAK,sBAAsB,GAAG;IAAE,SAAS,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IACnC,MAAM,EAAE,sBAAsB,EAAE,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,SAAS,6BAA4C,CAAC;AACnE,eAAO,MAAM,WAAW,6BAA8C,CAAC;AACvE,eAAO,MAAM,aAAa,6BAAgD,CAAC;AAE3E,wBAAgB,uBAAuB,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,cAAc,EAAE,EAAE,OAAO,GAAG,SAAS,CAQ9F;AAED,wBAAgB,qBAAqB,CAAC,EAAE,cAAc,EAAE,kBAAkB,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,KAAK,GAAG,SAAS,CAQ9G;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,cAAc,EAC9B,GAAG,EAAE,UAAU,GACd,SAAS,CAUX;AAID,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAc/F"}

package/packages/jam/transition/disputes/verification-utils.js

@@ -0,0 +1,47 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { ed25519 } from "#@typeberry/crypto";
+export const JAM_VALID = BytesBlob.blobFromString("jam_valid").raw;
+export const JAM_INVALID = BytesBlob.blobFromString("jam_invalid").raw;
+export const JAM_GUARANTEE = BytesBlob.blobFromString("jam_guarantee").raw;
+export function prepareCulpritSignature({ key, signature, workReportHash }) {
+    const message = BytesBlob.blobFromParts(JAM_GUARANTEE, workReportHash.raw);
+    return {
+        key,
+        signature,
+        message,
+    };
+}
+export function prepareFaultSignature({ workReportHash, wasConsideredValid, signature, key }) {
+    const signingContext = wasConsideredValid ? JAM_VALID : JAM_INVALID;
+    const message = BytesBlob.blobFromParts(signingContext, workReportHash.raw);
+    return {
+        key,
+        signature,
+        message,
+    };
+}
+export function prepareJudgementSignature(judgement, workReportHash, key) {
+    const { isWorkReportValid, signature } = judgement;
+    const signingContext = isWorkReportValid ? JAM_VALID : JAM_INVALID;
+    const message = BytesBlob.blobFromParts(signingContext, workReportHash.raw);
+    return {
+        key,
+        signature,
+        message,
+    };
+}
+// Verification is heavy and currently it is a bottleneck so in the future it will be outsourced to Rust.
+// This is why the data structure is complicated but it should allow to pass whole data to Rust at once.
+export async function vefifyAllSignatures(input) {
+    const output = { culprits: [], faults: [], judgements: [] };
+    const inputEntries = Object.entries(input);
+    for (const [key, signatureGroup] of inputEntries) {
+        output[key] = (await ed25519.verify(signatureGroup)).map((isValid, idx) => {
+            return {
+                isValid,
+                signature: signatureGroup[idx].signature,
+            };
+        });
+    }
+    return Promise.resolve(output);
+}

package/packages/jam/transition/disputes/verification-utils.test.d.ts

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

package/packages/jam/transition/disputes/verification-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-utils.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/verification-utils.test.ts"],"names":[],"mappings":""}

package/packages/jam/transition/disputes/verification-utils.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsValidatorIndex } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { ED25519_KEY_BYTES, ED25519_SIGNATURE_BYTES, initWasm } from "#@typeberry/crypto";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { prepareCulpritSignature, prepareJudgementSignature, vefifyAllSignatures } from "./verification-utils.js";
+before(async () => {
+    await initWasm();
+});
+describe("verification-utils", () => {
+    describe("verifyVoteSignature", () => {
+        it("should return true for valid signature and valid work report", async () => {
+            const signature = Bytes.parseBytes("0x0b1e29dbda5e3bba5dde21c81a8178b115ebf0cf5920fe1a38e897ecadd91718e34bf01c9fc7fdd0df31d83020231b6e8338c8dc204b618cbde16a03cb269d05", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+            const isWorkReportValid = true;
+            const item = prepareJudgementSignature({ index: tryAsValidatorIndex(0), isWorkReportValid, signature }, workReportHash, key);
+            const { judgements } = await vefifyAllSignatures({ culprits: [], faults: [], judgements: [item] });
+            assert.strictEqual(judgements[0].isValid, true);
+        });
+        it("should return false for invalid signature (value of isWorkReportValid is changed)", async () => {
+            const signature = Bytes.parseBytes("0x0b1e29dbda5e3bba5dde21c81a8178b115ebf0cf5920fe1a38e897ecadd91718e34bf01c9fc7fdd0df31d83020231b6e8338c8dc204b618cbde16a03cb269d05", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+            const isWorkReportValid = false;
+            const item = prepareJudgementSignature({ index: tryAsValidatorIndex(0), isWorkReportValid, signature }, workReportHash, key);
+            const { judgements } = await vefifyAllSignatures({ culprits: [], faults: [], judgements: [item] });
+            assert.strictEqual(judgements[0].isValid, false);
+        });
+        it("should return true for valid signature and invalid work report", async () => {
+            const signature = Bytes.parseBytes("0xd76bba06ffb8042bedce3f598e22423660e64f2108566cbd548f6d2c42b1a39607a214bddfa7ccccf83fe993728a58393c64283b8a9ab8f3dff49cbc3cc2350e", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x7b0aa1735e5ba58d3236316c671fe4f00ed366ee72417c9ed02a53a8019e85b8", HASH_SIZE).asOpaque();
+            const isWorkReportValid = false;
+            const item = prepareJudgementSignature({ index: tryAsValidatorIndex(0), isWorkReportValid, signature }, workReportHash, key);
+            const { judgements } = await vefifyAllSignatures({ culprits: [], faults: [], judgements: [item] });
+            assert.strictEqual(judgements[0].isValid, true);
+        });
+        it("should return false for invalid signature (the first byte in signature is changed)", async () => {
+            const signature = Bytes.parseBytes("0x1b1e29dbda5e3bba5dde21c81a8178b115ebf0cf5920fe1a38e897ecadd91718e34bf01c9fc7fdd0df31d83020231b6e8338c8dc204b618cbde16a03cb269d05", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+            const isWorkReportValid = true;
+            const item = prepareJudgementSignature({ index: tryAsValidatorIndex(0), isWorkReportValid, signature }, workReportHash, key);
+            const { judgements } = await vefifyAllSignatures({ culprits: [], faults: [], judgements: [item] });
+            assert.strictEqual(judgements[0].isValid, false);
+        });
+    });
+    describe("verifyCulpritSignature", () => {
+        it("should return true for valid signature", async () => {
+            const signature = Bytes.parseBytes("0xf23e45d7f8977a8eda61513bd5cab1451eb64f265edf340c415f25480123391364521f9bb4c14f840a0dae20eb4dc4a735c961d9966da51dde0d85281dc1dc0b", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+            const item = prepareCulpritSignature({ key, signature, workReportHash });
+            const { culprits } = await vefifyAllSignatures({ culprits: [item], faults: [], judgements: [] });
+            assert.strictEqual(culprits[0].isValid, true);
+        });
+        it("should return false for invalid signature (the first byte in signature is changed)", async () => {
+            const signature = Bytes.parseBytes("0xe23e45d7f8977a8eda61513bd5cab1451eb64f265edf340c415f25480123391364521f9bb4c14f840a0dae20eb4dc4a735c961d9966da51dde0d85281dc1dc0b", ED25519_SIGNATURE_BYTES).asOpaque();
+            const key = Bytes.parseBytes("0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29", ED25519_KEY_BYTES).asOpaque();
+            const workReportHash = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+            const item = prepareCulpritSignature({ key, signature, workReportHash });
+            const { culprits } = await vefifyAllSignatures({ culprits: [item], faults: [], judgements: [] });
+            assert.strictEqual(culprits[0].isValid, false);
+        });
+    });
+});