@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/jam/transition/block-verifier.js

@@ -0,0 +1,67 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { Result } from "#@typeberry/utils";
+export var BlockVerifierError;
+(function (BlockVerifierError) {
+    BlockVerifierError[BlockVerifierError["ParentNotFound"] = 0] = "ParentNotFound";
+    BlockVerifierError[BlockVerifierError["InvalidTimeSlot"] = 1] = "InvalidTimeSlot";
+    BlockVerifierError[BlockVerifierError["InvalidExtrinsic"] = 2] = "InvalidExtrinsic";
+    BlockVerifierError[BlockVerifierError["StateRootNotFound"] = 3] = "StateRootNotFound";
+    BlockVerifierError[BlockVerifierError["InvalidStateRoot"] = 4] = "InvalidStateRoot";
+    BlockVerifierError[BlockVerifierError["AlreadyImported"] = 5] = "AlreadyImported";
+})(BlockVerifierError || (BlockVerifierError = {}));
+const ZERO_HASH = Bytes.zero(HASH_SIZE).asOpaque();
+export class BlockVerifier {
+    hasher;
+    blocks;
+    constructor(hasher, blocks) {
+        this.hasher = hasher;
+        this.blocks = blocks;
+    }
+    async verifyBlock(block, options = { skipParentAndStateRoot: false }) {
+        const headerView = block.header.view();
+        const headerHash = this.hasher.header(headerView);
+        // check if current block is already imported
+        if (this.blocks.getHeader(headerHash.hash) !== null) {
+            return Result.error(BlockVerifierError.AlreadyImported, () => `Block ${headerHash.hash} is already imported.`);
+        }
+        // Check if parent block exists.
+        // https://graypaper.fluffylabs.dev/#/cc517d7/0c82000c8200?v=0.6.5
+        // https://graypaper.fluffylabs.dev/#/cc517d7/0c9d000c9d00?v=0.6.5
+        const parentHash = headerView.parentHeaderHash.materialize();
+        // importing genesis block
+        if (!parentHash.isEqualTo(ZERO_HASH) && !options.skipParentAndStateRoot) {
+            const parentBlock = this.blocks.getHeader(parentHash);
+            if (parentBlock === null) {
+                return Result.error(BlockVerifierError.ParentNotFound, () => `Parent ${parentHash.toString()} not found`);
+            }
+            // Check if the time slot index is consecutive and not from future.
+            // https://graypaper.fluffylabs.dev/#/cc517d7/0c02010c0201?v=0.6.5
+            const timeslot = headerView.timeSlotIndex.materialize();
+            const parentTimeslot = parentBlock.timeSlotIndex.materialize();
+            if (timeslot <= parentTimeslot) {
+                return Result.error(BlockVerifierError.InvalidTimeSlot, () => `Invalid time slot index: ${timeslot}, expected > ${parentTimeslot}`);
+            }
+        }
+        // Check if extrinsic is valid.
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/0cba000cba00?v=0.7.2
+        const extrinsicHash = headerView.extrinsicHash.materialize();
+        const extrinsicMerkleCommitment = this.hasher.extrinsic(block.extrinsic.view());
+        if (!extrinsicHash.isEqualTo(extrinsicMerkleCommitment.hash)) {
+            return Result.error(BlockVerifierError.InvalidExtrinsic, () => `Invalid extrinsic hash: ${extrinsicHash.toString()}, expected ${extrinsicMerkleCommitment.hash.toString()}`);
+        }
+        if (!options.skipParentAndStateRoot) {
+            // Check if the state root is valid.
+            // https://graypaper.fluffylabs.dev/#/ab2cdbd/0c73010c7301?v=0.7.2
+            const stateRoot = headerView.priorStateRoot.materialize();
+            const posteriorStateRoot = this.blocks.getPostStateRoot(parentHash);
+            if (posteriorStateRoot === null) {
+                return Result.error(BlockVerifierError.StateRootNotFound, () => `Posterior state root ${parentHash.toString()} not found`);
+            }
+            if (!stateRoot.isEqualTo(posteriorStateRoot)) {
+                return Result.error(BlockVerifierError.InvalidStateRoot, () => `Invalid prior state root: ${stateRoot.toString()}, expected ${posteriorStateRoot.toString()} (ours)`);
+            }
+        }
+        return Result.ok(headerHash.hash);
+    }
+}

package/packages/jam/transition/block-verifier.test.d.ts

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

package/packages/jam/transition/block-verifier.test.d.ts.map

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

package/packages/jam/transition/block-verifier.test.js

@@ -0,0 +1,116 @@
+import { describe, it } from "node:test";
+import { Block, Header, tryAsTimeSlot, } from "#@typeberry/block";
+import { testBlockView } from "#@typeberry/block/test-helpers.js";
+import { Bytes } from "#@typeberry/bytes";
+import { Decoder, Encoder } from "#@typeberry/codec";
+import { tinyChainSpec } from "#@typeberry/config";
+import { InMemoryBlocks } from "#@typeberry/database";
+import { Blake2b, HASH_SIZE, keccak, WithHash } from "#@typeberry/hash";
+import { deepEqual, Result } from "#@typeberry/utils";
+import { BlockVerifier, BlockVerifierError } from "./block-verifier.js";
+import { TransitionHasher } from "./hasher.js";
+const DEFAULT_HEADER_HASH = Bytes.fill(HASH_SIZE, 1).asOpaque();
+const DEFAULT_EXTRINSIC_HASH = Bytes.fill(HASH_SIZE, 2).asOpaque();
+const DEFAULT_STATE_ROOT = Bytes.fill(HASH_SIZE, 10).asOpaque();
+const DEFAULT_TIME_SLOT = tryAsTimeSlot(1);
+describe("Block Verifier", async () => {
+    const spec = tinyChainSpec;
+    const hasher = new TransitionHasher(await keccak.KeccakHasher.create(), await Blake2b.createHasher());
+    const toBlockView = (block) => {
+        const encodedBlock = Encoder.encodeObject(Block.Codec, block, spec);
+        const blockView = Decoder.decodeObject(Block.Codec.View, encodedBlock, spec);
+        return blockView;
+    };
+    const prepareBlocksDb = (db, { headerHash, timeSlot, stateRootHash, prepareStateRoot = false, } = {}) => {
+        const baseBlock = testBlockView().materialize();
+        const timeSlotIndex = timeSlot ?? DEFAULT_TIME_SLOT;
+        const header = Header.create({ ...baseBlock.header, timeSlotIndex });
+        const block = Block.create({ ...baseBlock, header });
+        const blockView = toBlockView(block);
+        const headerHashOrDefault = headerHash ?? DEFAULT_HEADER_HASH;
+        const stateRoot = stateRootHash ?? DEFAULT_STATE_ROOT;
+        db.insertBlock(new WithHash(headerHashOrDefault, blockView));
+        if (prepareStateRoot) {
+            db.setPostStateRoot(headerHashOrDefault, stateRoot);
+        }
+        db.setBestHeaderHash(headerHashOrDefault);
+    };
+    const prepareBlock = ({ parentHash, timeSlot, priorStateRootHash, correctExtrinsic = true, } = {}) => {
+        const block = testBlockView().materialize();
+        const extrinsicHash = correctExtrinsic
+            ? hasher.extrinsic(testBlockView().extrinsic.view()).hash
+            : DEFAULT_EXTRINSIC_HASH;
+        const header = Header.create({
+            ...block.header,
+            timeSlotIndex: timeSlot ?? tryAsTimeSlot(DEFAULT_TIME_SLOT + 1),
+            parentHeaderHash: parentHash ?? DEFAULT_HEADER_HASH,
+            priorStateRoot: priorStateRootHash ?? DEFAULT_STATE_ROOT,
+            extrinsicHash,
+        });
+        return Block.create({ ...block, header });
+    };
+    it("should return ParentNotFound error if parent block is not found", async () => {
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb, { headerHash: Bytes.fill(HASH_SIZE, 7).asOpaque() });
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({ parentHash: Bytes.fill(HASH_SIZE, 8).asOpaque() });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        deepEqual(result, Result.error(BlockVerifierError.ParentNotFound, () => "Parent 0x0808080808080808080808080808080808080808080808080808080808080808 not found"));
+    });
+    it("should return InvalidTimeSlot error if current block is older than parent block", async () => {
+        const timeSlot = tryAsTimeSlot(42);
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb, { timeSlot });
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({ timeSlot: tryAsTimeSlot(timeSlot - 2) });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        deepEqual(result, Result.error(BlockVerifierError.InvalidTimeSlot, () => "Invalid time slot index: 40, expected > 42"));
+    });
+    it("should return InvalidExtrinsic error if current block extrinsic hash is incorrect", async () => {
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb);
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({ correctExtrinsic: false });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        deepEqual(result, Result.error(BlockVerifierError.InvalidExtrinsic, () => "Invalid extrinsic hash: 0x0202020202020202020202020202020202020202020202020202020202020202, expected 0x0377c11c61a370e532ce1b18a652aecdd060a3a3a257d53dac8f8e1cb32dea98"));
+    });
+    it("should return StateRootNotFound error if posterior state root of parent hash is not set", async () => {
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb, {
+            stateRootHash: Bytes.fill(HASH_SIZE, 6).asOpaque(),
+            prepareStateRoot: false,
+        });
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({
+            priorStateRootHash: Bytes.fill(HASH_SIZE, 7).asOpaque(),
+            correctExtrinsic: true,
+        });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        deepEqual(result, Result.error(BlockVerifierError.StateRootNotFound, () => "Posterior state root 0x0101010101010101010101010101010101010101010101010101010101010101 not found"));
+    });
+    it("should return InvalidStateRoot error if current block priorStateRoot hash is not the same as posterior state root", async () => {
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb, {
+            stateRootHash: Bytes.fill(HASH_SIZE, 6).asOpaque(),
+            prepareStateRoot: true,
+        });
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({
+            priorStateRootHash: Bytes.fill(HASH_SIZE, 7).asOpaque(),
+            correctExtrinsic: true,
+        });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        deepEqual(result, Result.error(BlockVerifierError.InvalidStateRoot, () => "Invalid prior state root: 0x0707070707070707070707070707070707070707070707070707070707070707, expected 0x0606060606060606060606060606060606060606060606060606060606060606 (ours)"));
+    });
+    it("should return valid header hash if all checks pass", async () => {
+        const blocksDb = InMemoryBlocks.new();
+        prepareBlocksDb(blocksDb, { prepareStateRoot: true });
+        const blockVerifier = new BlockVerifier(hasher, blocksDb);
+        const block = prepareBlock({
+            correctExtrinsic: true,
+        });
+        const result = await blockVerifier.verifyBlock(toBlockView(block));
+        const expectedResult = "0x81201f77f6a370731846cae2cbe3cf462c05feacebc3c546347fa4e442fd4fad";
+        deepEqual(result, Result.ok(Bytes.parseBytes(expectedResult, HASH_SIZE).asOpaque()));
+    });
+});

package/packages/jam/transition/chain-stf.d.ts

@@ -0,0 +1,72 @@
+import type { BlockView, HeaderHash, TimeSlot } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { BlocksDb } from "#@typeberry/database";
+import { type DisputesStateUpdate } from "#@typeberry/disputes";
+import type { DisputesErrorCode } from "#@typeberry/disputes/disputes-error-code.js";
+import type { SafroleErrorCode, SafroleStateUpdate } from "#@typeberry/safrole/safrole.js";
+import { type SafroleSealError } from "#@typeberry/safrole/safrole-seal.js";
+import type { State, WithStateView } from "#@typeberry/state";
+import { type ErrorResult, Result, type TaggedError } from "#@typeberry/utils";
+import { type ACCUMULATION_ERROR, type AccumulateOptions, type AccumulateStateUpdate, type DeferredTransfersErrorCode } from "./accumulate/index.js";
+import { type AssurancesError, type AssurancesStateUpdate } from "./assurances.js";
+import { type AuthorizationStateUpdate } from "./authorization.js";
+import type { TransitionHasher } from "./hasher.js";
+import { type PreimagesErrorCode, type PreimagesStateUpdate } from "./preimages.js";
+import { type RecentHistoryStateUpdate } from "./recent-history.js";
+import { type HeaderChain, type ReportsError, type ReportsStateUpdate } from "./reports/index.js";
+import { type StatisticsStateUpdate } from "./statistics.js";
+export declare class DbHeaderChain implements HeaderChain {
+    private readonly blocks;
+    static new(blocks: BlocksDb): DbHeaderChain;
+    private constructor();
+    isAncestor(pastHeaderSlot: TimeSlot, pastHeader: HeaderHash, currentHeader: HeaderHash): boolean;
+}
+declare const OFFENDERS_ERROR = "offenders not matching header";
+type OFFENDERS_ERROR = typeof OFFENDERS_ERROR;
+export type Ok = SafroleStateUpdate & DisputesStateUpdate & ReportsStateUpdate & AssurancesStateUpdate & PreimagesStateUpdate & RecentHistoryStateUpdate & AuthorizationStateUpdate & AccumulateStateUpdate & StatisticsStateUpdate;
+export declare enum StfErrorKind {
+    Assurances = 0,
+    Disputes = 1,
+    Safrole = 2,
+    Reports = 3,
+    Preimages = 4,
+    SafroleSeal = 5,
+    Accumulate = 6,
+    DeferredTransfers = 7,
+    Offenders = 8
+}
+export type StfError = TaggedError<StfErrorKind.Assurances, AssurancesError> | TaggedError<StfErrorKind.Reports, ReportsError> | TaggedError<StfErrorKind.Disputes, DisputesErrorCode> | TaggedError<StfErrorKind.Safrole, SafroleErrorCode> | TaggedError<StfErrorKind.Preimages, PreimagesErrorCode> | TaggedError<StfErrorKind.SafroleSeal, SafroleSealError> | TaggedError<StfErrorKind.Accumulate, ACCUMULATION_ERROR> | TaggedError<StfErrorKind.DeferredTransfers, DeferredTransfersErrorCode> | TaggedError<StfErrorKind.Offenders, OFFENDERS_ERROR>;
+export declare const stfError: <Kind extends StfErrorKind, Err extends StfError["error"]>(kind: Kind, nested: ErrorResult<Err>) => Result<Ok, {
+    readonly kind: Kind;
+    readonly error: Err;
+    readonly enumMapping: {
+        [x: string]: string | number;
+    };
+    toString(): string;
+}>;
+export declare class OnChain {
+    readonly chainSpec: ChainSpec;
+    readonly state: State & WithStateView;
+    readonly hasher: TransitionHasher;
+    private readonly safrole;
+    private readonly safroleSeal;
+    private readonly disputes;
+    private readonly reports;
+    private readonly assurances;
+    private readonly accumulate;
+    private readonly accumulateOutput;
+    private readonly deferredTransfers;
+    private readonly preimages;
+    private readonly recentHistory;
+    private readonly authorization;
+    private readonly statistics;
+    private isReadyForNextEpoch;
+    constructor(chainSpec: ChainSpec, state: State & WithStateView, hasher: TransitionHasher, options: AccumulateOptions, headerChain: HeaderChain);
+    /** Pre-populate things worth caching for the next epoch. */
+    prepareForNextEpoch(): Promise<void>;
+    private verifySeal;
+    transition(block: BlockView, headerHash: HeaderHash): Promise<Result<Ok, StfError>>;
+    private getUsedAuthorizerHashes;
+}
+export {};
+//# sourceMappingURL=chain-stf.d.ts.map

package/packages/jam/transition/chain-stf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-stf.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/chain-stf.ts"],"names":[],"mappings":"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"}

package/packages/jam/transition/chain-stf.js

@@ -0,0 +1,329 @@
+import { asKnownSize, HashSet } from "#@typeberry/collections";
+import { PvmBackend } from "#@typeberry/config";
+import { Disputes } from "#@typeberry/disputes";
+import { Logger } from "#@typeberry/logger";
+import { Safrole } from "#@typeberry/safrole";
+import { BandernsatchWasm } from "#@typeberry/safrole/bandersnatch-wasm.js";
+import { SafroleSeal } from "#@typeberry/safrole/safrole-seal.js";
+import { assertEmpty, Compatibility, check, GpVersion, measure, OK, Result, } from "#@typeberry/utils";
+import { AccumulateOutput } from "./accumulate/accumulate-output.js";
+import { Accumulate, DeferredTransfers, } from "./accumulate/index.js";
+import { Assurances } from "./assurances.js";
+import { Authorization } from "./authorization.js";
+import { Preimages } from "./preimages.js";
+import { RecentHistory } from "./recent-history.js";
+import { Reports } from "./reports/index.js";
+import { Statistics } from "./statistics.js";
+export class DbHeaderChain {
+    blocks;
+    static new(blocks) {
+        return new DbHeaderChain(blocks);
+    }
+    constructor(blocks) {
+        this.blocks = blocks;
+    }
+    isAncestor(pastHeaderSlot, pastHeader, currentHeader) {
+        let currentHash = currentHeader;
+        for (;;) {
+            // success = we found the right header in the DB
+            if (currentHash.isEqualTo(pastHeader)) {
+                return true;
+            }
+            const current = this.blocks.getHeader(currentHash);
+            // fail if we don't find a parent (unlikely?)
+            if (current === null) {
+                return false;
+            }
+            // fail if we went pass that time slot index
+            if (current.timeSlotIndex.materialize() < pastHeaderSlot) {
+                return false;
+            }
+            // move one block up
+            currentHash = current.parentHeaderHash.materialize();
+        }
+    }
+}
+const OFFENDERS_ERROR = "offenders not matching header";
+export var StfErrorKind;
+(function (StfErrorKind) {
+    StfErrorKind[StfErrorKind["Assurances"] = 0] = "Assurances";
+    StfErrorKind[StfErrorKind["Disputes"] = 1] = "Disputes";
+    StfErrorKind[StfErrorKind["Safrole"] = 2] = "Safrole";
+    StfErrorKind[StfErrorKind["Reports"] = 3] = "Reports";
+    StfErrorKind[StfErrorKind["Preimages"] = 4] = "Preimages";
+    StfErrorKind[StfErrorKind["SafroleSeal"] = 5] = "SafroleSeal";
+    StfErrorKind[StfErrorKind["Accumulate"] = 6] = "Accumulate";
+    StfErrorKind[StfErrorKind["DeferredTransfers"] = 7] = "DeferredTransfers";
+    StfErrorKind[StfErrorKind["Offenders"] = 8] = "Offenders";
+})(StfErrorKind || (StfErrorKind = {}));
+export const stfError = (kind, nested) => {
+    return Result.taggedError(StfErrorKind, kind, nested);
+};
+const logger = Logger.new(import.meta.filename, "stf");
+export class OnChain {
+    chainSpec;
+    state;
+    hasher;
+    // chapter 6: https://graypaper.fluffylabs.dev/#/68eaa1f/0d13000d1300?v=0.6.4
+    safrole;
+    safroleSeal;
+    // chapter 10: https://graypaper.fluffylabs.dev/#/68eaa1f/11a30111a301?v=0.6.4
+    disputes;
+    // chapter 11: https://graypaper.fluffylabs.dev/#/68eaa1f/133100133100?v=0.6.4
+    reports;
+    assurances;
+    // chapter 12: https://graypaper.fluffylabs.dev/#/68eaa1f/159f02159f02?v=0.6.4
+    accumulate;
+    accumulateOutput;
+    // chapter 12.3: https://graypaper.fluffylabs.dev/#/68eaa1f/178203178203?v=0.6.4
+    deferredTransfers;
+    // chapter 12.4: https://graypaper.fluffylabs.dev/#/68eaa1f/18cc0018cc00?v=0.6.4
+    preimages;
+    // after accumulation
+    // chapter 7: https://graypaper.fluffylabs.dev/#/68eaa1f/0faf010faf01?v=0.6.4
+    recentHistory;
+    // chapter 8: https://graypaper.fluffylabs.dev/#/68eaa1f/0f94020f9402?v=0.6.4
+    authorization;
+    // chapter 13: https://graypaper.fluffylabs.dev/#/68eaa1f/18b60118b601?v=0.6.4
+    statistics;
+    isReadyForNextEpoch = Promise.resolve(false);
+    constructor(chainSpec, state, hasher, options, headerChain) {
+        this.chainSpec = chainSpec;
+        this.state = state;
+        this.hasher = hasher;
+        const bandersnatch = BandernsatchWasm.new();
+        this.statistics = new Statistics(chainSpec, state);
+        this.safrole = new Safrole(chainSpec, hasher.blake2b, state, bandersnatch);
+        this.safroleSeal = new SafroleSeal(bandersnatch);
+        this.recentHistory = new RecentHistory(hasher, state);
+        this.disputes = new Disputes(chainSpec, hasher.blake2b, state);
+        this.reports = new Reports(chainSpec, hasher.blake2b, state, headerChain);
+        this.assurances = new Assurances(chainSpec, state, hasher.blake2b);
+        this.accumulate = new Accumulate(chainSpec, hasher.blake2b, state, options);
+        this.accumulateOutput = new AccumulateOutput();
+        this.deferredTransfers = new DeferredTransfers(chainSpec, hasher.blake2b, state, options.pvm);
+        this.preimages = new Preimages(state, hasher.blake2b);
+        this.authorization = new Authorization(chainSpec, state);
+    }
+    /** Pre-populate things worth caching for the next epoch. */
+    async prepareForNextEpoch() {
+        if (await this.isReadyForNextEpoch) {
+            return;
+        }
+        const ready = this.safrole.prepareValidatorKeysForNextEpoch(this.state.disputesRecords.punishSet);
+        this.isReadyForNextEpoch = ready.then((_) => true);
+    }
+    async verifySeal(timeSlot, block) {
+        const sealState = this.safrole.getSafroleSealState(timeSlot);
+        return await this.safroleSeal.verifyHeaderSeal(block.header.view(), sealState);
+    }
+    async transition(block, headerHash) {
+        const headerView = block.header.view();
+        const header = block.header.materialize();
+        const timeSlot = header.timeSlotIndex;
+        // reset the epoch cache state
+        if (headerView.epochMarker.view() !== null) {
+            this.isReadyForNextEpoch = Promise.resolve(false);
+        }
+        // safrole seal
+        const sealResult = await this.verifySeal(timeSlot, block);
+        if (sealResult.isError) {
+            return stfError(StfErrorKind.SafroleSeal, sealResult);
+        }
+        const newEntropyHash = sealResult.ok;
+        // disputes
+        const disputesResult = await this.disputes.transition(block.extrinsic.view().disputes.materialize());
+        if (disputesResult.isError) {
+            return stfError(StfErrorKind.Disputes, disputesResult);
+        }
+        const { stateUpdate: { disputesRecords, availabilityAssignment: disputesAvailAssignment, ...disputesRest }, offendersMark, } = disputesResult.ok;
+        assertEmpty(disputesRest);
+        const headerOffendersMark = block.header.view().offendersMarker.materialize();
+        const offendersResult = checkOffendersMatch(offendersMark, headerOffendersMark);
+        if (offendersResult.isError) {
+            return stfError(StfErrorKind.Offenders, offendersResult);
+        }
+        // safrole
+        const safroleResult = await this.safrole.transition({
+            slot: timeSlot,
+            entropy: newEntropyHash,
+            extrinsic: block.extrinsic.view().tickets.materialize(),
+            punishSet: disputesRecords.punishSet,
+            epochMarker: headerView.epochMarker.view(),
+            ticketsMarker: headerView.ticketsMarker.view(),
+        });
+        if (safroleResult.isError) {
+            return stfError(StfErrorKind.Safrole, safroleResult);
+        }
+        const { timeslot, ticketsAccumulator, sealingKeySeries, epochRoot, entropy, nextValidatorData, currentValidatorData, previousValidatorData, ...safroleRest } = safroleResult.ok.stateUpdate;
+        assertEmpty(safroleRest);
+        // partial recent history
+        const recentHistoryPartialUpdate = this.recentHistory.partialTransition({
+            priorStateRoot: header.priorStateRoot,
+        });
+        const { recentBlocks: recentBlocksPartialUpdate, ...recentHistoryPartialRest } = recentHistoryPartialUpdate;
+        assertEmpty(recentHistoryPartialRest);
+        // assurances
+        const assurancesResult = await this.assurances.transition({
+            assurances: asKnownSize(block.extrinsic.view().assurances.view()),
+            slot: timeSlot,
+            parentHash: header.parentHeaderHash,
+            disputesAvailAssignment,
+        });
+        if (assurancesResult.isError) {
+            return stfError(StfErrorKind.Assurances, assurancesResult);
+        }
+        const { availableReports, stateUpdate: assurancesUpdate, ...assurancesRest } = assurancesResult.ok;
+        assertEmpty(assurancesRest);
+        const { availabilityAssignment: assurancesAvailAssignment, ...assurancesUpdateRest } = assurancesUpdate;
+        assertEmpty(assurancesUpdateRest);
+        // reports
+        const reportsResult = await this.reports.transition({
+            slot: timeSlot,
+            guarantees: block.extrinsic.view().guarantees.view(),
+            newEntropy: entropy,
+            recentBlocksPartialUpdate,
+            assurancesAvailAssignment,
+            offenders: offendersMark,
+            currentValidatorData,
+            previousValidatorData,
+        });
+        if (reportsResult.isError) {
+            return stfError(StfErrorKind.Reports, reportsResult);
+        }
+        const { reported: workPackages, reporters, stateUpdate: reportsUpdate, ...reportsRest } = reportsResult.ok;
+        assertEmpty(reportsRest);
+        const { availabilityAssignment: reportsAvailAssignment, ...reportsUpdateRest } = reportsUpdate;
+        assertEmpty(reportsUpdateRest);
+        // preimages
+        const preimagesResult = this.preimages.integrate({
+            slot: timeSlot,
+            preimages: block.extrinsic.view().preimages.materialize(),
+        });
+        if (preimagesResult.isError) {
+            return stfError(StfErrorKind.Preimages, preimagesResult);
+        }
+        const { preimages, ...preimagesRest } = preimagesResult.ok;
+        assertEmpty(preimagesRest);
+        const timerAccumulate = measure(`import:accumulate (${PvmBackend[this.accumulate.options.pvm]})`);
+        // accumulate
+        const accumulateResult = await this.accumulate.transition({
+            slot: timeSlot,
+            reports: availableReports,
+            entropy: entropy[0],
+        });
+        logger.log `${timerAccumulate()}`;
+        if (accumulateResult.isError) {
+            return stfError(StfErrorKind.Accumulate, accumulateResult);
+        }
+        const { stateUpdate: accumulateUpdate, accumulationStatistics, pendingTransfers, accumulationOutputLog, ...accumulateRest } = accumulateResult.ok;
+        assertEmpty(accumulateRest);
+        const { privilegedServices: maybePrivilegedServices, authQueues: maybeAuthorizationQueues, designatedValidatorData: maybeDesignatedValidatorData, preimages: accumulatePreimages, accumulationQueue, recentlyAccumulated, ...servicesUpdateFromAccumulate } = accumulateUpdate;
+        let transferStatistics = new Map();
+        let servicesUpdate = { ...servicesUpdateFromAccumulate, preimages: accumulatePreimages };
+        if (!Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
+            const deferredTransfersResult = await this.deferredTransfers.transition({
+                entropy: entropy[0],
+                pendingTransfers,
+                servicesUpdate,
+                timeslot: timeSlot,
+            });
+            if (deferredTransfersResult.isError) {
+                return stfError(StfErrorKind.DeferredTransfers, deferredTransfersResult);
+            }
+            const { servicesUpdate: servicesUpdateFromDeferredTransfers, transferStatistics: transferStatisticsFromDeferredTransfers, ...deferredTransfersRest } = deferredTransfersResult.ok;
+            transferStatistics = transferStatisticsFromDeferredTransfers;
+            servicesUpdate = servicesUpdateFromDeferredTransfers;
+            assertEmpty(deferredTransfersRest);
+        }
+        else {
+            check `${pendingTransfers.length === 0} All transfers should be already accumulated.`;
+        }
+        const accumulateRoot = await this.accumulateOutput.transition({ accumulationOutputLog });
+        // recent history
+        const recentHistoryUpdate = this.recentHistory.transition({
+            partial: recentHistoryPartialUpdate,
+            headerHash,
+            accumulateRoot,
+            workPackages,
+        });
+        const { recentBlocks, ...recentHistoryRest } = recentHistoryUpdate;
+        assertEmpty(recentHistoryRest);
+        // authorization
+        const authorizationUpdate = this.authorization.transition({
+            slot: timeSlot,
+            used: this.getUsedAuthorizerHashes(block.extrinsic.view().guarantees.view()),
+        });
+        const { authPools, ...authorizationRest } = authorizationUpdate;
+        assertEmpty(authorizationRest);
+        const extrinsic = block.extrinsic.materialize();
+        const statisticsUpdate = this.statistics.transition({
+            slot: timeSlot,
+            authorIndex: header.bandersnatchBlockAuthorIndex,
+            extrinsic,
+            incomingReports: extrinsic.guarantees.map((g) => g.report),
+            availableReports,
+            accumulationStatistics,
+            transferStatistics,
+            reporters: reporters,
+            currentValidatorData,
+        });
+        const { statistics, ...statisticsRest } = statisticsUpdate;
+        assertEmpty(statisticsRest);
+        // Concat accumulatePreimages updates with preimages
+        for (const [serviceId, accPreimageUpdates] of accumulatePreimages.entries()) {
+            const preimagesUpdates = preimages.get(serviceId);
+            if (preimagesUpdates === undefined) {
+                preimages.set(serviceId, accPreimageUpdates);
+            }
+            else {
+                preimages.set(serviceId, preimagesUpdates.concat(accPreimageUpdates));
+            }
+        }
+        return Result.ok({
+            ...(maybeAuthorizationQueues !== undefined ? { authQueues: maybeAuthorizationQueues } : {}),
+            ...(maybeDesignatedValidatorData !== undefined ? { designatedValidatorData: maybeDesignatedValidatorData } : {}),
+            ...(maybePrivilegedServices !== undefined ? { privilegedServices: maybePrivilegedServices } : {}),
+            authPools,
+            disputesRecords,
+            availabilityAssignment: reportsAvailAssignment,
+            recentBlocks,
+            statistics,
+            timeslot,
+            epochRoot,
+            entropy,
+            currentValidatorData,
+            nextValidatorData,
+            previousValidatorData,
+            sealingKeySeries,
+            ticketsAccumulator,
+            accumulationQueue,
+            recentlyAccumulated,
+            accumulationOutputLog,
+            ...servicesUpdate,
+            preimages,
+        });
+    }
+    getUsedAuthorizerHashes(guarantees) {
+        const map = new Map();
+        for (const guarantee of guarantees) {
+            const reportView = guarantee.view().report.view();
+            const coreIndex = reportView.coreIndex.materialize();
+            const ofCore = map.get(coreIndex) ?? HashSet.new();
+            ofCore.insert(reportView.authorizerHash.materialize());
+            map.set(coreIndex, ofCore);
+        }
+        return map;
+    }
+}
+function checkOffendersMatch(offendersMark, headerOffendersMark) {
+    if (offendersMark.size !== headerOffendersMark.length) {
+        return Result.error(OFFENDERS_ERROR, () => `Length mismatch: ${offendersMark.size} vs ${headerOffendersMark.length}`);
+    }
+    for (const key of headerOffendersMark) {
+        if (!offendersMark.has(key)) {
+            return Result.error(OFFENDERS_ERROR, () => `Missing key: ${key}`);
+        }
+    }
+    return Result.ok(OK);
+}

package/packages/jam/transition/disputes/disputes-error-code.d.ts

@@ -0,0 +1,19 @@
+export declare enum DisputesErrorCode {
+    AlreadyJudged = "already_judged",
+    BadVoteSplit = "bad_vote_split",
+    VerdictsNotSortedUnique = "verdicts_not_sorted_unique",
+    JudgementsNotSortedUnique = "judgements_not_sorted_unique",
+    CulpritsNotSortedUnique = "culprits_not_sorted_unique",
+    FaultsNotSortedUnique = "faults_not_sorted_unique",
+    NotEnoughCulprits = "not_enough_culprits",
+    NotEnoughFaults = "not_enough_faults",
+    CulpritsVerdictNotBad = "culprits_verdict_not_bad",
+    FaultVerdictWrong = "fault_verdict_wrong",
+    OffenderAlreadyReported = "offender_already_reported",
+    BadJudgementAge = "bad_judgement_age",
+    BadValidatorIndex = "bad_validator_index",
+    BadSignature = "bad_signature",
+    BadGuarantorKey = "bad_guarantor_key",
+    BadAuditorKey = "bad_auditor_key"
+}
+//# sourceMappingURL=disputes-error-code.d.ts.map

package/packages/jam/transition/disputes/disputes-error-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disputes-error-code.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/disputes-error-code.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,aAAa,mBAAmB;IAChC,YAAY,mBAAmB;IAC/B,uBAAuB,+BAA+B;IACtD,yBAAyB,iCAAiC;IAC1D,uBAAuB,+BAA+B;IACtD,qBAAqB,6BAA6B;IAClD,iBAAiB,wBAAwB;IACzC,eAAe,sBAAsB;IACrC,qBAAqB,6BAA6B;IAClD,iBAAiB,wBAAwB;IACzC,uBAAuB,8BAA8B;IACrD,eAAe,sBAAsB;IACrC,iBAAiB,wBAAwB;IACzC,YAAY,kBAAkB;IAC9B,eAAe,sBAAsB;IACrC,aAAa,oBAAoB;CAClC"}

package/packages/jam/transition/disputes/disputes-error-code.js

@@ -0,0 +1,19 @@
+export var DisputesErrorCode;
+(function (DisputesErrorCode) {
+    DisputesErrorCode["AlreadyJudged"] = "already_judged";
+    DisputesErrorCode["BadVoteSplit"] = "bad_vote_split";
+    DisputesErrorCode["VerdictsNotSortedUnique"] = "verdicts_not_sorted_unique";
+    DisputesErrorCode["JudgementsNotSortedUnique"] = "judgements_not_sorted_unique";
+    DisputesErrorCode["CulpritsNotSortedUnique"] = "culprits_not_sorted_unique";
+    DisputesErrorCode["FaultsNotSortedUnique"] = "faults_not_sorted_unique";
+    DisputesErrorCode["NotEnoughCulprits"] = "not_enough_culprits";
+    DisputesErrorCode["NotEnoughFaults"] = "not_enough_faults";
+    DisputesErrorCode["CulpritsVerdictNotBad"] = "culprits_verdict_not_bad";
+    DisputesErrorCode["FaultVerdictWrong"] = "fault_verdict_wrong";
+    DisputesErrorCode["OffenderAlreadyReported"] = "offender_already_reported";
+    DisputesErrorCode["BadJudgementAge"] = "bad_judgement_age";
+    DisputesErrorCode["BadValidatorIndex"] = "bad_validator_index";
+    DisputesErrorCode["BadSignature"] = "bad_signature";
+    DisputesErrorCode["BadGuarantorKey"] = "bad_guarantor_key";
+    DisputesErrorCode["BadAuditorKey"] = "bad_auditor_key";
+})(DisputesErrorCode || (DisputesErrorCode = {}));

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

@@ -0,0 +1,4 @@
+import type { State } from "#@typeberry/state";
+export type DisputesState = Pick<State, "disputesRecords" | "availabilityAssignment" | "timeslot" | "currentValidatorData" | "previousValidatorData">;
+export type DisputesStateUpdate = Pick<DisputesState, "disputesRecords" | "availabilityAssignment">;
+//# sourceMappingURL=disputes-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disputes-state.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/disputes/disputes-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG,IAAI,CAC9B,KAAK,EACL,iBAAiB,GAAG,wBAAwB,GAAG,UAAU,GAAG,sBAAsB,GAAG,uBAAuB,CAC7G,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,aAAa,EAAE,iBAAiB,GAAG,wBAAwB,CAAC,CAAC"}