@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/transition/disputes/disputes-state.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,39 @@
+import type { DisputesExtrinsic } from "#@typeberry/block/disputes.js";
+import { HashSet } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import type { Ed25519Key } from "#@typeberry/crypto";
+import type { Blake2b } from "#@typeberry/hash";
+import { Result } from "#@typeberry/utils";
+import { DisputesErrorCode } from "./disputes-error-code.js";
+import type { DisputesState, DisputesStateUpdate } from "./disputes-state.js";
+export declare class Disputes {
+    private readonly chainSpec;
+    private readonly blake2b;
+    readonly state: DisputesState;
+    constructor(chainSpec: ChainSpec, blake2b: Blake2b, state: DisputesState);
+    private verifyCulprits;
+    private verifyFaults;
+    private verifyVerdicts;
+    private verifyIfAlreadyJudged;
+    private calculateVotesForWorkReports;
+    private verifyVotesForWorkReports;
+    private getDisputesRecordsNewItems;
+    /**
+     * ρ†
+     * We clear any work-reports which we judged as uncertain or invalid from their core.
+     * https://graypaper.fluffylabs.dev/#/1c979cb/136900139e00?v=0.7.1
+     */
+    private getClearedCoreAssignment;
+    private getOffenders;
+    private getUpdatedDisputesRecords;
+    private prepareSignaturesToVerification;
+    private getValidatorKeys;
+    /**
+     * Transition the disputes and return a list of offenders.
+     */
+    transition(disputes: DisputesExtrinsic): Promise<Result<{
+        offendersMark: HashSet<Ed25519Key>;
+        stateUpdate: DisputesStateUpdate;
+    }, DisputesErrorCode>>;
+}
+//# sourceMappingURL=disputes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disputes.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/disputes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGtE,OAAO,EAAkB,OAAO,EAA0B,MAAM,wBAAwB,CAAC;AACzF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAQ/C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAc9E,qBAAa,QAAQ;IAEjB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,KAAK,EAAE,aAAa;gBAFnB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EACjB,KAAK,EAAE,aAAa;IAGtC,OAAO,CAAC,cAAc;IAoDtB,OAAO,CAAC,YAAY;IA8DpB,OAAO,CAAC,cAAc;IA6DtB,OAAO,CAAC,qBAAqB;IAoB7B,OAAO,CAAC,4BAA4B;IAsBpC,OAAO,CAAC,yBAAyB;IAoCjC,OAAO,CAAC,0BAA0B;IA0BlC;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,yBAAyB;IAWjC,OAAO,CAAC,+BAA+B;IAoCvC,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CACpD,MAAM,CACJ;QACE,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QACnC,WAAW,EAAE,mBAAmB,CAAC;KAClC,EACD,iBAAiB,CAClB,CACF;CAwCF"}

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

@@ -0,0 +1,335 @@
+import { WorkReport } from "#@typeberry/block/work-report.js";
+import { Encoder } from "#@typeberry/codec";
+import { HashDictionary, HashSet, SortedArray, SortedSet } from "#@typeberry/collections";
+import { DisputesRecords, hashComparator, tryAsPerCore, } from "#@typeberry/state";
+import { Result } from "#@typeberry/utils";
+import { DisputesErrorCode } from "./disputes-error-code.js";
+import { isUniqueSortedBy, isUniqueSortedByIndex } from "./sort-utils.js";
+import { prepareCulpritSignature, prepareFaultSignature, prepareJudgementSignature, vefifyAllSignatures, } from "./verification-utils.js";
+export class Disputes {
+    chainSpec;
+    blake2b;
+    state;
+    constructor(chainSpec, blake2b, state) {
+        this.chainSpec = chainSpec;
+        this.blake2b = blake2b;
+        this.state = state;
+    }
+    verifyCulprits(disputes, newItems, verificationResult, allValidatorKeys) {
+        // check if culprits are sorted by key
+        // https://graypaper.fluffylabs.dev/#/579bd12/12c50112c601
+        if (!isUniqueSortedBy(disputes.culprits, "key")) {
+            return Result.error(DisputesErrorCode.CulpritsNotSortedUnique, () => "Culprits are not uniquely sorted by key");
+        }
+        const culpritsLength = disputes.culprits.length;
+        for (let i = 0; i < culpritsLength; i++) {
+            const { key, workReportHash } = disputes.culprits[i];
+            // check if some offenders weren't reported earlier
+            // https://graypaper.fluffylabs.dev/#/579bd12/125501125501
+            const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
+            if (isInPunishSet) {
+                return Result.error(DisputesErrorCode.OffenderAlreadyReported, () => `Offender already reported: culprit ${i}, key=${key}`);
+            }
+            // check if the guarantor key is correct
+            // https://graypaper.fluffylabs.dev/#/85129da/125501125501?v=0.6.3
+            if (!allValidatorKeys.has(key)) {
+                return Result.error(DisputesErrorCode.BadGuarantorKey, () => `Bad guarantor key: culprit ${i}, key=${key}`);
+            }
+            // verify if the culprit will be in new bad set
+            // https://graypaper.fluffylabs.dev/#/579bd12/124601124601
+            const isInNewBadSet = newItems.asDictionaries().badSet.has(workReportHash);
+            if (!isInNewBadSet) {
+                return Result.error(DisputesErrorCode.CulpritsVerdictNotBad, () => `Culprit verdict not bad: culprit ${i}, work report=${workReportHash}`);
+            }
+            // verify culprit signature
+            // https://graypaper.fluffylabs.dev/#/579bd12/125c01125c01
+            const result = verificationResult.culprits[i];
+            if (!result?.isValid) {
+                return Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for culprit: ${i}`);
+            }
+        }
+        return Result.ok(null);
+    }
+    verifyFaults(disputes, newItems, verificationResult, allValidatorKeys) {
+        // check if faults are sorted by key
+        // https://graypaper.fluffylabs.dev/#/579bd12/12c50112c601
+        if (!isUniqueSortedBy(disputes.faults, "key")) {
+            return Result.error(DisputesErrorCode.FaultsNotSortedUnique, () => "Faults are not uniquely sorted by key");
+        }
+        const faultsLength = disputes.faults.length;
+        for (let i = 0; i < faultsLength; i++) {
+            const { key, workReportHash, wasConsideredValid } = disputes.faults[i];
+            // check if some offenders weren't reported earlier
+            // https://graypaper.fluffylabs.dev/#/579bd12/12a20112a201
+            const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
+            if (isInPunishSet) {
+                return Result.error(DisputesErrorCode.OffenderAlreadyReported, () => `Offender already reported: fault ${i}, key=${key}`);
+            }
+            // check if the auditor key is correct
+            // https://graypaper.fluffylabs.dev/#/85129da/12a20112a201?v=0.6.3
+            if (!allValidatorKeys.has(key)) {
+                return Result.error(DisputesErrorCode.BadAuditorKey, () => `Bad auditor key: fault ${i}, key=${key}`);
+            }
+            // verify if the fault will be included in new good/bad set
+            // it may be not correct as in GP there is "iff" what means it should be rather
+            // if (!wasConsideredValid || isInNewGoodSet || !isInNewBadSet) return DisputesErrorCode.FaultVerdictWrong;
+            // but it does not pass the tests
+            // https://graypaper.fluffylabs.dev/#/579bd12/128a01129601
+            if (wasConsideredValid) {
+                const { goodSet, badSet } = newItems.asDictionaries();
+                const isInNewGoodSet = goodSet.has(workReportHash);
+                const isInNewBadSet = badSet.has(workReportHash);
+                if (isInNewGoodSet || !isInNewBadSet) {
+                    return Result.error(DisputesErrorCode.FaultVerdictWrong, () => `Fault verdict wrong: fault ${i}, work report=${workReportHash}, inGood=${isInNewGoodSet}, inBad=${isInNewBadSet}`);
+                }
+            }
+            // verify fault signature. Verification was done earlier, here we only check the result.
+            // https://graypaper.fluffylabs.dev/#/579bd12/12a90112a901
+            const result = verificationResult.faults[i];
+            if (!result.isValid) {
+                return Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for fault: ${i}`);
+            }
+        }
+        return Result.ok(null);
+    }
+    verifyVerdicts(disputes, verificationResult) {
+        // check if verdicts are correctly sorted
+        // https://graypaper.fluffylabs.dev/#/579bd12/12c40112c401
+        if (!isUniqueSortedBy(disputes.verdicts, "workReportHash")) {
+            return Result.error(DisputesErrorCode.VerdictsNotSortedUnique, () => "Verdicts are not uniquely sorted by work report hash");
+        }
+        // check if judgement are correctly sorted
+        // https://graypaper.fluffylabs.dev/#/579bd12/123702123802
+        if (disputes.verdicts.some((verdict) => !isUniqueSortedByIndex(verdict.votes))) {
+            return Result.error(DisputesErrorCode.JudgementsNotSortedUnique, () => "Judgements are not uniquely sorted by index");
+        }
+        const currentEpoch = Math.floor(this.state.timeslot / this.chainSpec.epochLength);
+        let voteSignatureIndex = 0;
+        for (const { votesEpoch, votes } of disputes.verdicts) {
+            // https://graypaper.fluffylabs.dev/#/579bd12/12bb0012bc00
+            if (votesEpoch !== currentEpoch && votesEpoch + 1 !== currentEpoch) {
+                return Result.error(DisputesErrorCode.BadJudgementAge, () => `Bad judgement age: epoch=${votesEpoch}, current=${currentEpoch}`);
+            }
+            const k = votesEpoch === currentEpoch ? this.state.currentValidatorData : this.state.previousValidatorData;
+            for (const { index } of votes) {
+                const key = k[index]?.ed25519;
+                // no particular GP fragment but I think we don't believe in ghosts
+                if (key === undefined) {
+                    return Result.error(DisputesErrorCode.BadValidatorIndex, () => `Bad validator index: ${index} in epoch ${votesEpoch}`);
+                }
+                // verify vote signature. Verification was done earlier, here we only check the result.
+                // https://graypaper.fluffylabs.dev/#/579bd12/12cd0012cd00
+                const result = verificationResult.judgements[voteSignatureIndex];
+                if (!result.isValid) {
+                    return Result.error(DisputesErrorCode.BadSignature, () => `Invalid signature for judgement: ${voteSignatureIndex}`);
+                }
+                voteSignatureIndex += 1;
+            }
+        }
+        return Result.ok(null);
+    }
+    verifyIfAlreadyJudged(disputes) {
+        for (const verdict of disputes.verdicts) {
+            // current verdicts should not be reported earlier
+            // https://graypaper.fluffylabs.dev/#/579bd12/122202122202
+            const { goodSet, badSet, wonkySet } = this.state.disputesRecords.asDictionaries();
+            const isInGoodSet = goodSet.has(verdict.workReportHash);
+            const isInBadSet = badSet.has(verdict.workReportHash);
+            const isInWonkySet = wonkySet.has(verdict.workReportHash);
+            if (isInGoodSet || isInBadSet || isInWonkySet) {
+                return Result.error(DisputesErrorCode.AlreadyJudged, () => `Work report already judged: ${verdict.workReportHash}`);
+            }
+        }
+        return Result.ok(null);
+    }
+    calculateVotesForWorkReports(disputes) {
+        // calculate total votes for each work report
+        // https://graypaper.fluffylabs.dev/#/579bd12/128c0212e302
+        const v = HashDictionary.new();
+        for (const verdict of disputes.verdicts) {
+            const j = verdict.votes;
+            const r = verdict.workReportHash;
+            let sum = 0;
+            for (const { isWorkReportValid } of j) {
+                if (isWorkReportValid) {
+                    sum += 1;
+                }
+            }
+            v.set(r, sum);
+        }
+        return v;
+    }
+    verifyVotesForWorkReports(v, disputes) {
+        // verify if the vote split is correct and if number of faults/culprits is correct
+        // https://graypaper.fluffylabs.dev/#/579bd12/12fb02121003
+        for (const [r, sum] of v) {
+            if (sum === this.chainSpec.validatorsSuperMajority) {
+                // there has to be at least 1 fault with the same work report hash
+                // https://graypaper.fluffylabs.dev/#/579bd12/12f10212fc02
+                const f = disputes.faults.find((x) => x.workReportHash.isEqualTo(r));
+                if (f === undefined) {
+                    return Result.error(DisputesErrorCode.NotEnoughFaults, () => `Not enough faults for work report: ${r}`);
+                }
+            }
+            else if (sum === 0) {
+                // there has to be at least 2 culprits with the same work report hash
+                // https://graypaper.fluffylabs.dev/#/579bd12/120c03121003
+                const c1 = disputes.culprits.find((x) => x.workReportHash.isEqualTo(r));
+                const c2 = disputes.culprits.findLast((x) => x.workReportHash.isEqualTo(r));
+                if (c1 === c2) {
+                    return Result.error(DisputesErrorCode.NotEnoughCulprits, () => `Not enough culprits for work report: ${r}`);
+                }
+            }
+            else if (sum !== this.chainSpec.thirdOfValidators) {
+                // positive votes count is not correct
+                // https://graypaper.fluffylabs.dev/#/579bd12/125002128102
+                return Result.error(DisputesErrorCode.BadVoteSplit, () => `Bad vote split: sum=${sum}, expected=${this.chainSpec.thirdOfValidators} for work report ${r}`);
+            }
+        }
+        return Result.ok(null);
+    }
+    getDisputesRecordsNewItems(v) {
+        const toAddToGoodSet = [];
+        const toAddToBadSet = [];
+        const toAddToWonkySet = [];
+        // prepare new disputes records items but do not update the state yet
+        // the state will be updated after verification
+        // https://graypaper.fluffylabs.dev/#/579bd12/124a0312a503
+        for (const [r, sum] of v) {
+            if (sum >= this.chainSpec.validatorsSuperMajority) {
+                toAddToGoodSet.push(r);
+            }
+            else if (sum === 0) {
+                toAddToBadSet.push(r);
+            }
+            else if (sum >= this.chainSpec.thirdOfValidators) {
+                toAddToWonkySet.push(r);
+            }
+        }
+        return DisputesRecords.create({
+            goodSet: SortedSet.fromArrayUnique(hashComparator, toAddToGoodSet),
+            badSet: SortedSet.fromArrayUnique(hashComparator, toAddToBadSet),
+            wonkySet: SortedSet.fromArrayUnique(hashComparator, toAddToWonkySet),
+            punishSet: SortedSet.fromArray(hashComparator, []),
+        });
+    }
+    /**
+     * ρ†
+     * We clear any work-reports which we judged as uncertain or invalid from their core.
+     * https://graypaper.fluffylabs.dev/#/1c979cb/136900139e00?v=0.7.1
+     */
+    getClearedCoreAssignment(v) {
+        // count how many votes we have left to process
+        let votesLeft = v.size;
+        // go through each core and check for results, but early exit if
+        // there is no more votes to process
+        const availabilityAssignment = this.state.availabilityAssignment.slice();
+        for (let c = 0; c < availabilityAssignment.length && votesLeft > 0; c++) {
+            const assignment = availabilityAssignment[c];
+            if (assignment !== null) {
+                const encoded = Encoder.encodeObject(WorkReport.Codec, assignment.workReport, this.chainSpec);
+                const hash = this.blake2b.hashBytes(encoded).asOpaque();
+                const sum = v.get(hash);
+                if (sum !== undefined) {
+                    votesLeft--;
+                    if (sum < this.chainSpec.validatorsSuperMajority) {
+                        availabilityAssignment[c] = null;
+                    }
+                }
+            }
+        }
+        return tryAsPerCore(availabilityAssignment, this.chainSpec);
+    }
+    getOffenders(disputes) {
+        // https://graypaper.fluffylabs.dev/#/579bd12/12bb0312bb03
+        const offendersMarks = HashSet.new();
+        for (const { key } of disputes.culprits) {
+            offendersMarks.insert(key);
+        }
+        for (const { key } of disputes.faults) {
+            offendersMarks.insert(key);
+        }
+        return offendersMarks;
+    }
+    getUpdatedDisputesRecords(newItems, offenders) {
+        const toAddToPunishSet = SortedArray.fromArray(hashComparator, Array.from(offenders));
+        return DisputesRecords.create({
+            // https://graypaper.fluffylabs.dev/#/579bd12/12690312bc03
+            goodSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.goodSet, newItems.goodSet),
+            badSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.badSet, newItems.badSet),
+            wonkySet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.wonkySet, newItems.wonkySet),
+            punishSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.punishSet, toAddToPunishSet),
+        });
+    }
+    prepareSignaturesToVerification(disputes) {
+        // Signature verification is heavy so we prepare data to verify it in the meantime,
+        const signaturesToVerification = { culprits: [], judgements: [], faults: [] };
+        const currentEpoch = Math.floor(this.state.timeslot / this.chainSpec.epochLength);
+        for (const { votesEpoch, votes, workReportHash } of disputes.verdicts) {
+            const k = votesEpoch === currentEpoch ? this.state.currentValidatorData : this.state.previousValidatorData;
+            for (const j of votes) {
+                const validator = k[j.index];
+                // no particular GP fragment but I think we don't believe in ghosts
+                if (validator === undefined) {
+                    return Result.error(DisputesErrorCode.BadValidatorIndex, () => `Bad validator index in signature verification: ${j.index}`);
+                }
+                const key = validator.ed25519;
+                // verify vote signature
+                // https://graypaper.fluffylabs.dev/#/579bd12/12cd0012cd00
+                signaturesToVerification.judgements.push(prepareJudgementSignature(j, workReportHash, key));
+            }
+        }
+        // verify culprit signature
+        // https://graypaper.fluffylabs.dev/#/579bd12/125c01125c01
+        signaturesToVerification.culprits = disputes.culprits.map(prepareCulpritSignature);
+        // verify fault signature
+        // https://graypaper.fluffylabs.dev/#/579bd12/12a90112a901
+        signaturesToVerification.faults = disputes.faults.map(prepareFaultSignature);
+        return Result.ok(signaturesToVerification);
+    }
+    getValidatorKeys() {
+        const punishSetKeys = this.state.disputesRecords.punishSet;
+        const currentValidatorKeys = this.state.currentValidatorData.map((v) => v.ed25519);
+        const previousValidatorKeys = this.state.previousValidatorData.map((v) => v.ed25519);
+        const allValidatorKeys = currentValidatorKeys
+            .concat(previousValidatorKeys)
+            .filter((key) => !punishSetKeys.has(key));
+        return HashSet.from(allValidatorKeys);
+    }
+    /**
+     * Transition the disputes and return a list of offenders.
+     */
+    async transition(disputes) {
+        const signaturesToVerifyResult = this.prepareSignaturesToVerification(disputes);
+        if (signaturesToVerifyResult.isError) {
+            return signaturesToVerifyResult;
+        }
+        const signaturesToVerify = signaturesToVerifyResult.ok;
+        const verificationPromise = vefifyAllSignatures(signaturesToVerify);
+        const v = this.calculateVotesForWorkReports(disputes);
+        const newItems = this.getDisputesRecordsNewItems(v);
+        const verificationResult = await verificationPromise;
+        const allValidatorKeys = this.getValidatorKeys();
+        const inputError = [
+            this.verifyVerdicts(disputes, verificationResult),
+            this.verifyVotesForWorkReports(v, disputes),
+            this.verifyCulprits(disputes, newItems, verificationResult, allValidatorKeys),
+            this.verifyFaults(disputes, newItems, verificationResult, allValidatorKeys),
+            this.verifyIfAlreadyJudged(disputes),
+        ].find((result) => result.isError);
+        if (inputError?.isError) {
+            return inputError;
+        }
+        // GP: https://graypaper.fluffylabs.dev/#/579bd12/131300133000
+        const offendersMark = this.getOffenders(disputes);
+        const disputesRecords = this.getUpdatedDisputesRecords(newItems, offendersMark);
+        const availabilityAssignment = this.getClearedCoreAssignment(v);
+        return Result.ok({
+            offendersMark,
+            stateUpdate: {
+                disputesRecords,
+                availabilityAssignment,
+            },
+        });
+    }
+}

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

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

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

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

package/packages/jam/transition/disputes/disputes.test.data.d.ts

@@ -0,0 +1,38 @@
+import { Culprit, Fault, Judgement, Verdict } from "#@typeberry/block/disputes.js";
+import { ValidatorData } from "#@typeberry/state";
+export declare const currentValidatorData: readonly ValidatorData[] & import("@typeberry/utils").WithOpaque<"ValidatorsCount">;
+export declare const previousValidatorData: readonly ValidatorData[] & import("@typeberry/utils").WithOpaque<"ValidatorsCount">;
+export declare const culprits: Culprit[];
+export declare const verdicts: Verdict[];
+export declare const verdictsWithIncorrectValidatorIndex: Verdict[];
+export declare const faults: Fault[];
+export declare function createVerdict({ target, age, votes, }: {
+    target: string;
+    age: number;
+    votes: {
+        vote: boolean;
+        index: number;
+        signature: string;
+    }[];
+}): Verdict;
+export declare function createCulprit({ target, key, signature }: {
+    target: string;
+    key: string;
+    signature: string;
+}): Culprit;
+export declare function createFault({ target, vote, key, signature, }: {
+    target: string;
+    vote: boolean;
+    key: string;
+    signature: string;
+}): Fault;
+export declare function createVote({ vote, index, signature }: {
+    vote: boolean;
+    index: number;
+    signature: string;
+}): Judgement;
+export declare function createValidatorData({ bandersnatch, ed25519 }: {
+    bandersnatch: string;
+    ed25519: string;
+}): ValidatorData;
+//# sourceMappingURL=disputes.test.data.d.ts.map

package/packages/jam/transition/disputes/disputes.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disputes.test.data.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/disputes.test.data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAMlF,OAAO,EAAwB,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEvE,eAAO,MAAM,oBAAoB,qFA4BhC,CAAC;AAEF,eAAO,MAAM,qBAAqB,qFA4BjC,CAAC;AAEF,eAAO,MAAM,QAAQ,WAaD,CAAC;AAErB,eAAO,MAAM,QAAQ,WAyED,CAAC;AAErB,eAAO,MAAM,mCAAmC,WAqC5B,CAAC;AAErB,eAAO,MAAM,MAAM,SAQD,CAAC;AAEnB,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,GAAG,EACH,KAAK,GACN,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC9D,WAMA;AAED,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,WAM3G;AAED,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,IAAI,EACJ,GAAG,EACH,SAAS,GACV,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB,SAOA;AAED,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,aAMzG;AAED,wBAAgB,mBAAmB,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,iBAOvG"}

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

@@ -0,0 +1,214 @@
+import { tryAsEpoch, tryAsPerValidator, tryAsValidatorIndex } from "#@typeberry/block";
+import { Culprit, Fault, Judgement, Verdict } from "#@typeberry/block/disputes.js";
+import { Bytes } from "#@typeberry/bytes";
+import { asKnownSize } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { BANDERSNATCH_KEY_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES, ED25519_SIGNATURE_BYTES } from "#@typeberry/crypto";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { VALIDATOR_META_BYTES, ValidatorData } from "#@typeberry/state";
+export const currentValidatorData = tryAsPerValidator([
+    {
+        bandersnatch: "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+        ed25519: "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+    },
+    {
+        bandersnatch: "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+        ed25519: "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+    },
+    {
+        bandersnatch: "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+        ed25519: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+    },
+    {
+        bandersnatch: "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+        ed25519: "0xb3e0e096b02e2ec98a3441410aeddd78c95e27a0da6f411a09c631c0f2bea6e9",
+    },
+    {
+        bandersnatch: "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+        ed25519: "0x5c7f34a4bd4f2d04076a8c6f9060a0c8d2c6bdd082ceb3eda7df381cb260faff",
+    },
+    {
+        bandersnatch: "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+        ed25519: "0x837ce344bc9defceb0d7de7e9e9925096768b7adb4dad932e532eb6551e0ea02",
+    },
+].map(createValidatorData), tinyChainSpec);
+export const previousValidatorData = tryAsPerValidator([
+    {
+        bandersnatch: "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+        ed25519: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+    },
+    {
+        bandersnatch: "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+        ed25519: "0x837ce344bc9defceb0d7de7e9e9925096768b7adb4dad932e532eb6551e0ea02",
+    },
+    {
+        bandersnatch: "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+        ed25519: "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+    },
+    {
+        bandersnatch: "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+        ed25519: "0x5c7f34a4bd4f2d04076a8c6f9060a0c8d2c6bdd082ceb3eda7df381cb260faff",
+    },
+    {
+        bandersnatch: "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+        ed25519: "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+    },
+    {
+        bandersnatch: "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+        ed25519: "0xb3e0e096b02e2ec98a3441410aeddd78c95e27a0da6f411a09c631c0f2bea6e9",
+    },
+].map(createValidatorData), tinyChainSpec);
+export const culprits = [
+    {
+        target: "0x7b0aa1735e5ba58d3236316c671fe4f00ed366ee72417c9ed02a53a8019e85b8",
+        key: "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+        signature: "0xa6a135b2f36906be1c00cd0e48425a38cbde296a5ff73d6de6d3b0e4c26f1761adbf563961da0d3611c24ee8f5c5781647f327513912cb58f1de4bc72b5e6f01",
+    },
+    {
+        target: "0x7b0aa1735e5ba58d3236316c671fe4f00ed366ee72417c9ed02a53a8019e85b8",
+        key: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+        signature: "0x940439909168820e32e5788b293786e1e02e7377e32260a96997cb991638c8c88980d0a7a6f26c7fb9bb81282129fdaa09c87932db02cbfd9955dc1940b90a03",
+    },
+].map(createCulprit);
+export const verdicts = [
+    {
+        target: "0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9",
+        age: 0,
+        votes: [
+            {
+                vote: true,
+                index: 0,
+                signature: "0x0b1e29dbda5e3bba5dde21c81a8178b115ebf0cf5920fe1a38e897ecadd91718e34bf01c9fc7fdd0df31d83020231b6e8338c8dc204b618cbde16a03cb269d05",
+            },
+            {
+                vote: true,
+                index: 1,
+                signature: "0x0d44746706e09ff6b6f2929e736c2f868a4d17939af6d37ca7d3c7f6d4914bd095a6fd4ff48c320b673e2de92bfdb5ed9f5c0c40749816ab4171a2272386fc05",
+            },
+            {
+                vote: true,
+                index: 2,
+                signature: "0x0d5d39f2239b775b22aff53b74a0d708a9b9363ed5017170f0abebc8ffd97fc1cc3cf597c578b555ad5abab26e09ecda727c2909feae99587c6354b86e4cc50c",
+            },
+            {
+                vote: true,
+                index: 3,
+                signature: "0x701d277fa78993b343a5d4367f1c2a2fb7ddb77f0246bf9028196feccbb7c0f2bd994966b3e9b1e51ff5dd63d8aa5e2331432b9cca4a125552c4700d51814a04",
+            },
+            {
+                vote: true,
+                index: 4,
+                signature: "0x08d96d2e49546931dc3de989a69aa0ae3547d67a038bdaa84f7e549da8318d48aab72b4b30ecc0c588696305fce3e2c4657f409463f6a05c52bf641f2684460f",
+            },
+        ],
+    },
+    {
+        target: "0x7b0aa1735e5ba58d3236316c671fe4f00ed366ee72417c9ed02a53a8019e85b8",
+        age: 0,
+        votes: [
+            {
+                vote: false,
+                index: 0,
+                signature: "0xd76bba06ffb8042bedce3f598e22423660e64f2108566cbd548f6d2c42b1a39607a214bddfa7ccccf83fe993728a58393c64283b8a9ab8f3dff49cbc3cc2350e",
+            },
+            {
+                vote: false,
+                index: 1,
+                signature: "0x77edbe63b2cfab4bda9227bc9fcc8ac4aa8157616c3d8dff9f90fe88cc998fef871a57bbc43eaa1bdee241a1f903ffb42e39a4207c0752d9352f7d98835eda0a",
+            },
+            {
+                vote: false,
+                index: 2,
+                signature: "0x1843d18350a8ddee1502bc47cbd1dd30a3354f24bf7e095ad848e8f0744afc4b04a224b5b2143297d571309799c3c0a17f1b7d7782aaeb8f4991cf5dd749310b",
+            },
+            {
+                vote: false,
+                index: 3,
+                signature: "0x561bab9479abe38ed5d9609e92145fa689995ef2b71e94577a60eee6177663e8fd1f5bacd1f1afdadce1ea48598ad10a0893e733c34ab6f4aa821b0fdbdf0201",
+            },
+            {
+                vote: false,
+                index: 4,
+                signature: "0xb579159c1ab983583ed8d95bf8632ac7d3be51bdff3d5221258105b801782a5146e08247c269c7bcec10bec76c7d648704e7e6bf3ace77951e828f23894b500c",
+            },
+        ],
+    },
+].map(createVerdict);
+export const verdictsWithIncorrectValidatorIndex = [
+    {
+        target: "0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9",
+        age: 0,
+        votes: [
+            {
+                vote: true,
+                index: 65000,
+                signature: "0x0b1e29dbda5e3bba5dde21c81a8178b115ebf0cf5920fe1a38e897ecadd91718e34bf01c9fc7fdd0df31d83020231b6e8338c8dc204b618cbde16a03cb269d05",
+            },
+            {
+                vote: true,
+                index: 1,
+                signature: "0x0d44746706e09ff6b6f2929e736c2f868a4d17939af6d37ca7d3c7f6d4914bd095a6fd4ff48c320b673e2de92bfdb5ed9f5c0c40749816ab4171a2272386fc05",
+            },
+            {
+                vote: true,
+                index: 2,
+                signature: "0x0d5d39f2239b775b22aff53b74a0d708a9b9363ed5017170f0abebc8ffd97fc1cc3cf597c578b555ad5abab26e09ecda727c2909feae99587c6354b86e4cc50c",
+            },
+            {
+                vote: true,
+                index: 3,
+                signature: "0x701d277fa78993b343a5d4367f1c2a2fb7ddb77f0246bf9028196feccbb7c0f2bd994966b3e9b1e51ff5dd63d8aa5e2331432b9cca4a125552c4700d51814a04",
+            },
+            {
+                vote: true,
+                index: 4,
+                signature: "0x08d96d2e49546931dc3de989a69aa0ae3547d67a038bdaa84f7e549da8318d48aab72b4b30ecc0c588696305fce3e2c4657f409463f6a05c52bf641f2684460f",
+            },
+        ],
+    },
+].map(createVerdict);
+export const faults = [
+    {
+        target: "0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9",
+        vote: false,
+        key: "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+        signature: "0x826a4bbe7ee3400ffe0f64bdd87ae65aa50d98f48ad6a60da927636cd430ae5d3914d3bc6b87c47c94a9cc5bef84bf30be5534e5c649fc2cd4434918a37a2301",
+    },
+].map(createFault);
+export function createVerdict({ target, age, votes, }) {
+    return Verdict.create({
+        workReportHash: Bytes.parseBytes(target, HASH_SIZE).asOpaque(),
+        votesEpoch: tryAsEpoch(age),
+        votes: asKnownSize(votes.map(createVote)),
+    });
+}
+export function createCulprit({ target, key, signature }) {
+    return Culprit.create({
+        workReportHash: Bytes.parseBytes(target, HASH_SIZE).asOpaque(),
+        key: Bytes.parseBytes(key, ED25519_KEY_BYTES).asOpaque(),
+        signature: Bytes.parseBytes(signature, ED25519_SIGNATURE_BYTES).asOpaque(),
+    });
+}
+export function createFault({ target, vote, key, signature, }) {
+    return Fault.create({
+        workReportHash: Bytes.parseBytes(target, HASH_SIZE).asOpaque(),
+        wasConsideredValid: vote,
+        key: Bytes.parseBytes(key, ED25519_KEY_BYTES).asOpaque(),
+        signature: Bytes.parseBytes(signature, ED25519_SIGNATURE_BYTES).asOpaque(),
+    });
+}
+export function createVote({ vote, index, signature }) {
+    return Judgement.create({
+        isWorkReportValid: vote,
+        index: tryAsValidatorIndex(index),
+        signature: Bytes.parseBytes(signature, ED25519_SIGNATURE_BYTES).asOpaque(),
+    });
+}
+export function createValidatorData({ bandersnatch, ed25519 }) {
+    return ValidatorData.create({
+        bandersnatch: Bytes.parseBytes(bandersnatch, BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: Bytes.parseBytes(ed25519, ED25519_KEY_BYTES).asOpaque(),
+        bls: Bytes.zero(BLS_KEY_BYTES).asOpaque(),
+        metadata: Bytes.zero(VALIDATOR_META_BYTES),
+    });
+}

package/packages/jam/transition/disputes/disputes.test.data2.d.ts

@@ -0,0 +1,9 @@
+import { type WorkPackageHash } from "#@typeberry/block/refine-context.js";
+import { WorkReport } from "#@typeberry/block/work-report.js";
+export declare const currentValidatorData: readonly import("@typeberry/state").ValidatorData[] & import("@typeberry/utils").WithOpaque<"ValidatorsCount">;
+export declare const previousValidatorData: readonly import("@typeberry/state").ValidatorData[] & import("@typeberry/utils").WithOpaque<"ValidatorsCount">;
+export declare const verdicts: import("@typeberry/block/disputes.js").Verdict[];
+export declare const culprits: import("@typeberry/block/disputes.js").Culprit[];
+export declare const faults: import("@typeberry/block/disputes.js").Fault[];
+export declare function workReport(packageHash: WorkPackageHash, coreIndex: number): WorkReport;
+//# sourceMappingURL=disputes.test.data2.d.ts.map

package/packages/jam/transition/disputes/disputes.test.data2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disputes.test.data2.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/disputes.test.data2.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACzF,OAAO,EAAmB,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAS9E,eAAO,MAAM,oBAAoB,gHA4BhC,CAAC;AAEF,eAAO,MAAM,qBAAqB,gHA4BjC,CAAC;AAEF,eAAO,MAAM,QAAQ,kDAyED,CAAC;AAErB,eAAO,MAAM,QAAQ,kDAaD,CAAC;AAErB,eAAO,MAAM,MAAM,gDAQD,CAAC;AAEnB,wBAAgB,UAAU,CAAC,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,cA4CzE"}