@typeberry/lib 0.5.1 → 0.5.2-03e1aed

package/packages/jam/transition/recent-history.test.js

@@ -0,0 +1,135 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Bytes } from "#@typeberry/bytes";
+import { HashDictionary } from "#@typeberry/collections";
+import { HASH_SIZE, keccak } from "#@typeberry/hash";
+import { BlockState, MAX_RECENT_HISTORY, RecentBlocks } from "#@typeberry/state";
+import { asOpaqueType, check } from "#@typeberry/utils";
+import { RecentHistory, } from "./recent-history.js";
+import { copyAndUpdateState } from "./test.utils.js";
+const hasher = keccak.KeccakHasher.create().then((hasher) => {
+    return {
+        hashConcat: (a, b) => keccak.hashBlobs(hasher, [a, b]),
+        hashConcatPrepend: (id, a, b) => keccak.hashBlobs(hasher, [id, a, b]),
+    };
+});
+const asRecentHistory = (arr, accumulationLog) => {
+    check `${arr.length <= MAX_RECENT_HISTORY} Invalid size of the state input.`;
+    return {
+        recentBlocks: RecentBlocks.create({
+            blocks: arr,
+            accumulationLog: accumulationLog ?? {
+                peaks: [],
+            },
+        }),
+    };
+};
+describe("Recent History", () => {
+    it("should perform a transition with empty state", async () => {
+        const initialState = asOpaqueType([]);
+        const recentHistory = new RecentHistory(await hasher, asRecentHistory(initialState));
+        const partialInput = {
+            priorStateRoot: Bytes.fill(HASH_SIZE, 3).asOpaque(),
+        };
+        const partialUpdate = recentHistory.partialTransition(partialInput);
+        const input = {
+            partial: partialUpdate,
+            headerHash: Bytes.fill(HASH_SIZE, 2).asOpaque(),
+            accumulateRoot: Bytes.fill(HASH_SIZE, 1).asOpaque(),
+            workPackages: HashDictionary.new(),
+        };
+        const stateUpdate = recentHistory.transition(input);
+        const state = copyAndUpdateState(recentHistory.state, stateUpdate);
+        assert.deepStrictEqual(state.recentBlocks, RecentBlocks.create({
+            blocks: asOpaqueType([
+                BlockState.create({
+                    headerHash: input.headerHash,
+                    accumulationResult: Bytes.fill(HASH_SIZE, 1),
+                    postStateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+                    reported: HashDictionary.new(),
+                }),
+            ]),
+            accumulationLog: {
+                peaks: [Bytes.fill(HASH_SIZE, 1)],
+            },
+        }));
+    });
+    it("should perform a transition with some state", async () => {
+        const firstBlock = BlockState.create({
+            headerHash: Bytes.fill(HASH_SIZE, 3).asOpaque(),
+            accumulationResult: Bytes.fill(HASH_SIZE, 2),
+            postStateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            reported: HashDictionary.new(),
+        });
+        const recentHistory = new RecentHistory(await hasher, asRecentHistory(asOpaqueType([firstBlock]), { peaks: [Bytes.fill(HASH_SIZE, 1)] }));
+        const partialInput = {
+            priorStateRoot: Bytes.fill(HASH_SIZE, 4).asOpaque(),
+        };
+        const partialUpdate = recentHistory.partialTransition(partialInput);
+        const input = {
+            partial: partialUpdate,
+            headerHash: Bytes.fill(HASH_SIZE, 5).asOpaque(),
+            accumulateRoot: Bytes.fill(HASH_SIZE, 6).asOpaque(),
+            workPackages: HashDictionary.fromEntries([
+                {
+                    workPackageHash: Bytes.fill(HASH_SIZE, 7).asOpaque(),
+                    segmentTreeRoot: Bytes.fill(HASH_SIZE, 8).asOpaque(),
+                },
+            ].map((x) => [x.workPackageHash, x])),
+        };
+        const stateUpdate = recentHistory.transition(input);
+        const state = copyAndUpdateState(recentHistory.state, stateUpdate);
+        const recentBlocks = state.recentBlocks;
+        assert.deepStrictEqual(recentBlocks.blocks.length, 2);
+        assert.deepStrictEqual(recentBlocks.blocks[0], BlockState.create({
+            ...firstBlock,
+            // note we fill it up from the input
+            postStateRoot: partialInput.priorStateRoot,
+        }));
+        assert.deepStrictEqual(recentBlocks.accumulationLog, {
+            peaks: [null, Bytes.parseBytes("0x6ac9e94853a54beddd428600d8dd68f9c67ea0850f6d9407812a48c71e9f6958", HASH_SIZE)],
+        });
+        assert.deepStrictEqual(recentBlocks.blocks[1], BlockState.create({
+            headerHash: input.headerHash,
+            accumulationResult: Bytes.parseBytes("0x6ac9e94853a54beddd428600d8dd68f9c67ea0850f6d9407812a48c71e9f6958", HASH_SIZE),
+            postStateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            reported: input.workPackages,
+        }));
+    });
+    it("should only keep 8 entries", async () => {
+        let input;
+        const initialState = asOpaqueType([]);
+        let state = asRecentHistory(initialState);
+        for (let i = 0; i < 10; i++) {
+            const recentHistory = new RecentHistory(await hasher, state);
+            const id = (x) => 10 * i + x;
+            const partialInput = {
+                priorStateRoot: Bytes.fill(HASH_SIZE, 1).asOpaque(),
+            };
+            const partialUpdate = recentHistory.partialTransition(partialInput);
+            input = {
+                partial: partialUpdate,
+                headerHash: Bytes.fill(HASH_SIZE, id(2)).asOpaque(),
+                accumulateRoot: Bytes.fill(HASH_SIZE, id(3)).asOpaque(),
+                workPackages: HashDictionary.fromEntries([
+                    {
+                        workPackageHash: Bytes.fill(HASH_SIZE, id(4)).asOpaque(),
+                        segmentTreeRoot: Bytes.fill(HASH_SIZE, id(5)).asOpaque(),
+                    },
+                ].map((x) => [x.workPackageHash, x])),
+            };
+            const stateUpdate = recentHistory.transition(input);
+            state = copyAndUpdateState(recentHistory.state, stateUpdate);
+        }
+        const recentBlocks = state.recentBlocks;
+        assert.deepStrictEqual(recentBlocks.blocks.length, 8);
+        assert.deepStrictEqual(recentBlocks.accumulationLog, {
+            peaks: [
+                null,
+                Bytes.parseBytes("0xf2b82ebf240c42d9a13a3282f81bc914af9795b8d376fee5ffa70271ad027ef6", HASH_SIZE),
+                null,
+                Bytes.parseBytes("0x9db02578e7a12b19a574f27104e51df3dbcce55d37611fac0abb5da9bd0f5b97", HASH_SIZE),
+            ],
+        });
+    });
+});

package/packages/jam/transition/reports/error.d.ts

@@ -0,0 +1,52 @@
+/** Error that may happen during reports processing. */
+export declare enum ReportsError {
+    /** Core index is greater than the number of available cores. */
+    BadCoreIndex = 0,
+    /** The report slot is greater than the current block slot. */
+    FutureReportSlot = 1,
+    /** Report is too old to be considered. */
+    ReportEpochBeforeLast = 2,
+    /** Not enough credentials for the guarantee. */
+    InsufficientGuarantees = 3,
+    /** Guarantees are not ordered by the core index. */
+    OutOfOrderGuarantee = 4,
+    /** Credentials of guarantors are not sorted or unique. */
+    NotSortedOrUniqueGuarantors = 5,
+    /** Validator in credentials is assigned to a different core. */
+    WrongAssignment = 6,
+    /** There is a report pending availability on that core already. */
+    CoreEngaged = 7,
+    /** Anchor block is not found in recent blocks. */
+    AnchorNotRecent = 8,
+    /** Service not foubd. */
+    BadServiceId = 9,
+    /** Service code hash does not match the current one. */
+    BadCodeHash = 10,
+    /** Pre-requisite work package is missing in either recent blocks or lookup extrinsic. */
+    DependencyMissing = 11,
+    /** Results for the same package are in more than one report. */
+    DuplicatePackage = 12,
+    /** Anchor block declared state root does not match the one we have in recent blocks. */
+    BadStateRoot = 13,
+    /** BEEFY super hash mmr mismatch. */
+    BadBeefyMmrRoot = 14,
+    /** The authorization hash is not found in the authorization pool. */
+    CoreUnauthorized = 15,
+    /** Validator index is greater than the number of validators. */
+    BadValidatorIndex = 16,
+    /** Total gas of work report is too high. */
+    WorkReportGasTooHigh = 17,
+    /** Work item has is smaller than required minimal accumulation gas of a service. */
+    ServiceItemGasTooLow = 18,
+    /** The report has too many dependencies (prerequisites and/or segment-root lookups). */
+    TooManyDependencies = 19,
+    /** Segment root lookup block has invalid time slot or is not found in the header chain. */
+    SegmentRootLookupInvalid = 20,
+    /** Signature in credentials is invalid. */
+    BadSignature = 21,
+    /** Size of authorizer output and all work-item successful output blobs is too big. */
+    WorkReportTooBig = 22,
+    /** Contains guarantee from validator that is proven to be an offender. */
+    BannedValidator = 23
+}
+//# sourceMappingURL=error.d.ts.map

package/packages/jam/transition/reports/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/reports/error.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,oBAAY,YAAY;IACtB,gEAAgE;IAChE,YAAY,IAAI;IAChB,8DAA8D;IAC9D,gBAAgB,IAAI;IACpB,0CAA0C;IAC1C,qBAAqB,IAAI;IACzB,gDAAgD;IAChD,sBAAsB,IAAI;IAC1B,oDAAoD;IACpD,mBAAmB,IAAI;IACvB,0DAA0D;IAC1D,2BAA2B,IAAI;IAC/B,gEAAgE;IAChE,eAAe,IAAI;IACnB,mEAAmE;IACnE,WAAW,IAAI;IACf,kDAAkD;IAClD,eAAe,IAAI;IACnB,yBAAyB;IACzB,YAAY,IAAI;IAChB,wDAAwD;IACxD,WAAW,KAAK;IAChB,yFAAyF;IACzF,iBAAiB,KAAK;IACtB,gEAAgE;IAChE,gBAAgB,KAAK;IACrB,wFAAwF;IACxF,YAAY,KAAK;IACjB,qCAAqC;IACrC,eAAe,KAAK;IACpB,qEAAqE;IACrE,gBAAgB,KAAK;IACrB,gEAAgE;IAChE,iBAAiB,KAAK;IACtB,4CAA4C;IAC5C,oBAAoB,KAAK;IACzB,oFAAoF;IACpF,oBAAoB,KAAK;IACzB,wFAAwF;IACxF,mBAAmB,KAAK;IACxB,2FAA2F;IAC3F,wBAAwB,KAAK;IAC7B,2CAA2C;IAC3C,YAAY,KAAK;IACjB,sFAAsF;IACtF,gBAAgB,KAAK;IACrB,0EAA0E;IAC1E,eAAe,KAAK;CACrB"}

package/packages/jam/transition/reports/error.js

@@ -0,0 +1,52 @@
+/** Error that may happen during reports processing. */
+export var ReportsError;
+(function (ReportsError) {
+    /** Core index is greater than the number of available cores. */
+    ReportsError[ReportsError["BadCoreIndex"] = 0] = "BadCoreIndex";
+    /** The report slot is greater than the current block slot. */
+    ReportsError[ReportsError["FutureReportSlot"] = 1] = "FutureReportSlot";
+    /** Report is too old to be considered. */
+    ReportsError[ReportsError["ReportEpochBeforeLast"] = 2] = "ReportEpochBeforeLast";
+    /** Not enough credentials for the guarantee. */
+    ReportsError[ReportsError["InsufficientGuarantees"] = 3] = "InsufficientGuarantees";
+    /** Guarantees are not ordered by the core index. */
+    ReportsError[ReportsError["OutOfOrderGuarantee"] = 4] = "OutOfOrderGuarantee";
+    /** Credentials of guarantors are not sorted or unique. */
+    ReportsError[ReportsError["NotSortedOrUniqueGuarantors"] = 5] = "NotSortedOrUniqueGuarantors";
+    /** Validator in credentials is assigned to a different core. */
+    ReportsError[ReportsError["WrongAssignment"] = 6] = "WrongAssignment";
+    /** There is a report pending availability on that core already. */
+    ReportsError[ReportsError["CoreEngaged"] = 7] = "CoreEngaged";
+    /** Anchor block is not found in recent blocks. */
+    ReportsError[ReportsError["AnchorNotRecent"] = 8] = "AnchorNotRecent";
+    /** Service not foubd. */
+    ReportsError[ReportsError["BadServiceId"] = 9] = "BadServiceId";
+    /** Service code hash does not match the current one. */
+    ReportsError[ReportsError["BadCodeHash"] = 10] = "BadCodeHash";
+    /** Pre-requisite work package is missing in either recent blocks or lookup extrinsic. */
+    ReportsError[ReportsError["DependencyMissing"] = 11] = "DependencyMissing";
+    /** Results for the same package are in more than one report. */
+    ReportsError[ReportsError["DuplicatePackage"] = 12] = "DuplicatePackage";
+    /** Anchor block declared state root does not match the one we have in recent blocks. */
+    ReportsError[ReportsError["BadStateRoot"] = 13] = "BadStateRoot";
+    /** BEEFY super hash mmr mismatch. */
+    ReportsError[ReportsError["BadBeefyMmrRoot"] = 14] = "BadBeefyMmrRoot";
+    /** The authorization hash is not found in the authorization pool. */
+    ReportsError[ReportsError["CoreUnauthorized"] = 15] = "CoreUnauthorized";
+    /** Validator index is greater than the number of validators. */
+    ReportsError[ReportsError["BadValidatorIndex"] = 16] = "BadValidatorIndex";
+    /** Total gas of work report is too high. */
+    ReportsError[ReportsError["WorkReportGasTooHigh"] = 17] = "WorkReportGasTooHigh";
+    /** Work item has is smaller than required minimal accumulation gas of a service. */
+    ReportsError[ReportsError["ServiceItemGasTooLow"] = 18] = "ServiceItemGasTooLow";
+    /** The report has too many dependencies (prerequisites and/or segment-root lookups). */
+    ReportsError[ReportsError["TooManyDependencies"] = 19] = "TooManyDependencies";
+    /** Segment root lookup block has invalid time slot or is not found in the header chain. */
+    ReportsError[ReportsError["SegmentRootLookupInvalid"] = 20] = "SegmentRootLookupInvalid";
+    /** Signature in credentials is invalid. */
+    ReportsError[ReportsError["BadSignature"] = 21] = "BadSignature";
+    /** Size of authorizer output and all work-item successful output blobs is too big. */
+    ReportsError[ReportsError["WorkReportTooBig"] = 22] = "WorkReportTooBig";
+    /** Contains guarantee from validator that is proven to be an offender. */
+    ReportsError[ReportsError["BannedValidator"] = 23] = "BannedValidator";
+})(ReportsError || (ReportsError = {}));

package/packages/jam/transition/reports/guarantor-assignment.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 11.3. Guarantor Assignments. Every block, each core
+ * has three validators uniquely assigned to guarantee work-
+ * reports for it. This is borne out with V= 1023 validators
+ * and C = 341 cores, since V/C = 3. The core index assigned to
+ * each of the validators, as well as the validators’ Ed25519
+ * keys are denoted by M.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/144c02145402?v=0.7.2
+ */
+import { type CoreIndex, type EntropyHash, type PerValidator, type TimeSlot } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import type { Blake2b } from "#@typeberry/hash";
+import { type Opaque } from "#@typeberry/utils";
+/** Index of the rotation calculated by dividing a timeslot by rotation period. */
+export type RotationIndex = Opaque<number, "RotationIndex">;
+/**
+ * Returns core assignments for each validator index.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/155300155d00?v=0.7.2
+ */
+export declare function generateCoreAssignment(spec: ChainSpec, blake2b: Blake2b, 
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/147102147102?v=0.7.2 */
+eta2entropy: EntropyHash, 
+/** timeslot */
+slot: TimeSlot): PerValidator<CoreIndex>;
+/** Calculate rotation index for given time slot. */
+export declare function rotationIndex(slot: TimeSlot, rotationPeriod: number): RotationIndex;
+//# sourceMappingURL=guarantor-assignment.d.ts.map

package/packages/jam/transition/reports/guarantor-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guarantor-assignment.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/reports/guarantor-assignment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE7D,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAE5D;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,OAAO;AAChB,sEAAsE;AACtE,WAAW,EAAE,WAAW;AACxB,eAAe;AACf,IAAI,EAAE,QAAQ,GACb,YAAY,CAAC,SAAS,CAAC,CAEzB;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,GAAG,aAAa,CAEnF"}

package/packages/jam/transition/reports/guarantor-assignment.js

@@ -0,0 +1,50 @@
+/**
+ * 11.3. Guarantor Assignments. Every block, each core
+ * has three validators uniquely assigned to guarantee work-
+ * reports for it. This is borne out with V= 1023 validators
+ * and C = 341 cores, since V/C = 3. The core index assigned to
+ * each of the validators, as well as the validators’ Ed25519
+ * keys are denoted by M.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/144c02145402?v=0.7.2
+ */
+import { tryAsCoreIndex, tryAsTimeSlot, } from "#@typeberry/block";
+import { asKnownSize } from "#@typeberry/collections";
+import { fisherYatesShuffle } from "#@typeberry/shuffling";
+import { asOpaqueType } from "#@typeberry/utils";
+/**
+ * Returns core assignments for each validator index.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/155300155d00?v=0.7.2
+ */
+export function generateCoreAssignment(spec, blake2b, 
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/147102147102?v=0.7.2 */
+eta2entropy, 
+/** timeslot */
+slot) {
+    return permute(blake2b, eta2entropy, slot, spec);
+}
+/** Calculate rotation index for given time slot. */
+export function rotationIndex(slot, rotationPeriod) {
+    return asOpaqueType(Math.floor(slot / rotationPeriod));
+}
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/151900151900?v=0.7.2 */
+function permute(blake2b, entropy, slot, spec) {
+    const shift = rotationIndex(tryAsTimeSlot(slot % spec.epochLength), spec.rotationPeriod);
+    const initialAssignment = Array(spec.validatorsCount)
+        .fill(0)
+        .map((_v, i) => {
+        // we are moving within `[0..1)` in `i/noOfValidators` component, hence we will
+        // get a valid `coreIndex` after multiplying by `noOfCores`.
+        return tryAsCoreIndex(Math.floor((i * spec.coresCount) / spec.validatorsCount));
+    });
+    const shuffledAssignment = fisherYatesShuffle(blake2b, initialAssignment, entropy);
+    const coreAssignment = rotate(shuffledAssignment, shift, spec.coresCount);
+    // we are sure this is PerValidator, since that's the array we create earlier.
+    return asKnownSize(coreAssignment);
+}
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/148002148002?v=0.7.2 */
+function rotate(cores, n, noOfCores) {
+    // modulo `noOfCores` guarantees that we're within `CoreIndex` range.
+    return cores.map((x) => asOpaqueType((x + n) % noOfCores));
+}

package/packages/jam/transition/reports/guarantor-assignment.test.d.ts

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

package/packages/jam/transition/reports/guarantor-assignment.test.d.ts.map

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

package/packages/jam/transition/reports/guarantor-assignment.test.js

@@ -0,0 +1,124 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsPerValidator, tryAsTimeSlot } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { fullChainSpec, tinyChainSpec } from "#@typeberry/config";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { deepEqual } from "#@typeberry/utils";
+import { generateCoreAssignment } from "./guarantor-assignment.js";
+let blake2b;
+before(async () => {
+    blake2b = await Blake2b.createHasher();
+});
+describe("Core assignment", () => {
+    it("should assign validators to cores in tinyChainSpec", async () => {
+        const spec = tinyChainSpec;
+        const entropy = Bytes.fill(HASH_SIZE, 1).asOpaque();
+        const coreAssignment1 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(1));
+        const coreAssignment2 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(11));
+        deepEqual(coreAssignment1, tryAsPerValidator([1, 1, 1, 0, 0, 0], spec));
+        deepEqual(coreAssignment2, tryAsPerValidator([1, 1, 1, 0, 0, 0], spec));
+    });
+    it("should assign validators to cores in tinyChainSpec - 2", async () => {
+        const spec = tinyChainSpec;
+        const entropy = Bytes.parseBytes("0x11da6d1f761ddf9bdb4c9d6e5303ebd41f61858d0a5647a1a7bfe089bf921be9", HASH_SIZE).asOpaque();
+        const coreAssignment1 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(14));
+        const coreAssignment2 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(11));
+        assert.deepStrictEqual(coreAssignment1, tryAsPerValidator([1, 0, 0, 1, 0, 1], spec));
+        assert.deepStrictEqual(coreAssignment2, tryAsPerValidator([1, 0, 0, 1, 0, 1], spec));
+    });
+    it("should assign validators to cores in fullChainSpec", async () => {
+        const spec = fullChainSpec;
+        const entropy = Bytes.fill(HASH_SIZE, 0xfe).asOpaque();
+        const coreAssignment1 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(1));
+        const coreAssignment2 = generateCoreAssignment(spec, blake2b, entropy, tryAsTimeSlot(132));
+        deepEqual(coreAssignment1.toString(), tryAsPerValidator(FULL_1, spec).toString());
+        deepEqual(coreAssignment2.toString(), tryAsPerValidator(FULL_2, spec).toString());
+    });
+});
+const FULL_1 = [
+    54, 104, 98, 198, 269, 242, 291, 11, 97, 113, 120, 257, 76, 113, 154, 277, 227, 15, 298, 128, 56, 133, 32, 162, 293,
+    313, 67, 91, 123, 137, 119, 168, 306, 148, 319, 74, 34, 325, 106, 134, 308, 191, 232, 22, 6, 27, 281, 264, 263, 251,
+    170, 262, 11, 183, 278, 286, 177, 318, 63, 252, 29, 306, 46, 286, 44, 340, 211, 21, 202, 227, 311, 322, 239, 245, 43,
+    122, 75, 120, 15, 211, 132, 212, 126, 8, 141, 94, 201, 61, 314, 257, 229, 152, 48, 68, 179, 186, 301, 157, 86, 130,
+    197, 307, 250, 296, 240, 65, 241, 130, 213, 233, 45, 309, 235, 332, 124, 93, 88, 225, 206, 316, 225, 284, 312, 336,
+    290, 302, 11, 331, 197, 253, 12, 40, 304, 51, 70, 301, 191, 25, 17, 160, 182, 264, 59, 270, 317, 78, 215, 10, 85, 26,
+    131, 193, 287, 181, 310, 251, 311, 219, 105, 299, 267, 179, 73, 187, 271, 166, 19, 174, 255, 188, 72, 55, 291, 16,
+    194, 55, 127, 29, 254, 269, 162, 79, 286, 36, 56, 221, 128, 102, 64, 62, 114, 251, 169, 44, 128, 78, 269, 261, 287,
+    92, 3, 17, 35, 42, 54, 298, 123, 279, 301, 127, 147, 195, 253, 144, 103, 118, 237, 68, 236, 304, 160, 116, 205, 184,
+    154, 98, 177, 152, 101, 35, 69, 297, 182, 125, 330, 43, 20, 22, 108, 149, 178, 329, 118, 278, 259, 292, 104, 180, 1,
+    176, 215, 178, 146, 324, 25, 7, 208, 302, 218, 209, 334, 193, 159, 198, 323, 235, 261, 33, 230, 322, 83, 97, 224, 327,
+    9, 136, 317, 81, 231, 84, 268, 63, 7, 121, 73, 320, 21, 135, 277, 180, 246, 312, 329, 66, 176, 112, 10, 273, 323, 218,
+    336, 318, 253, 330, 5, 339, 100, 258, 55, 303, 116, 107, 331, 175, 308, 129, 80, 171, 311, 165, 271, 285, 201, 332,
+    100, 56, 204, 217, 42, 275, 171, 207, 5, 25, 3, 222, 32, 138, 9, 64, 101, 190, 221, 231, 244, 41, 192, 236, 28, 33,
+    61, 12, 151, 191, 340, 45, 86, 226, 79, 89, 46, 118, 224, 148, 317, 303, 81, 161, 220, 228, 50, 338, 288, 247, 5, 106,
+    138, 224, 283, 33, 158, 214, 147, 102, 262, 173, 325, 319, 124, 199, 280, 163, 204, 150, 138, 188, 168, 92, 320, 261,
+    132, 16, 139, 293, 31, 310, 270, 239, 126, 305, 107, 272, 90, 64, 256, 252, 147, 134, 57, 223, 154, 140, 232, 276,
+    155, 266, 36, 328, 238, 175, 159, 38, 104, 130, 109, 157, 59, 80, 233, 298, 321, 213, 174, 172, 265, 105, 292, 305,
+    84, 222, 241, 248, 82, 170, 238, 26, 59, 110, 67, 250, 336, 205, 288, 319, 76, 266, 156, 148, 265, 61, 122, 36, 135,
+    37, 83, 178, 327, 173, 106, 18, 82, 208, 86, 52, 189, 199, 24, 96, 212, 85, 156, 270, 153, 92, 305, 57, 195, 202, 207,
+    246, 1, 94, 39, 315, 219, 87, 198, 71, 248, 296, 255, 249, 51, 155, 88, 304, 327, 161, 334, 201, 41, 258, 206, 290,
+    265, 163, 167, 333, 34, 314, 94, 258, 30, 96, 20, 99, 207, 135, 7, 295, 234, 140, 24, 132, 52, 18, 117, 44, 282, 14,
+    146, 190, 75, 53, 65, 210, 194, 282, 81, 129, 170, 243, 279, 220, 27, 23, 199, 117, 35, 67, 297, 244, 114, 96, 105,
+    333, 303, 18, 244, 58, 48, 47, 249, 300, 151, 66, 281, 339, 296, 40, 237, 45, 186, 143, 223, 150, 214, 217, 195, 20,
+    181, 146, 125, 116, 74, 21, 114, 192, 233, 274, 335, 295, 26, 95, 91, 217, 186, 93, 185, 182, 242, 13, 158, 307, 256,
+    316, 234, 260, 241, 177, 107, 243, 69, 71, 216, 230, 63, 165, 66, 280, 245, 299, 110, 4, 227, 24, 31, 179, 222, 276,
+    283, 76, 93, 271, 87, 290, 1, 99, 335, 266, 340, 300, 226, 111, 226, 89, 257, 84, 284, 74, 328, 203, 328, 153, 172,
+    183, 255, 274, 228, 279, 4, 247, 273, 192, 223, 62, 125, 39, 83, 171, 39, 193, 164, 277, 8, 158, 289, 54, 325, 126,
+    22, 307, 281, 149, 284, 176, 321, 240, 108, 295, 57, 267, 174, 145, 137, 289, 200, 31, 187, 0, 32, 15, 259, 262, 231,
+    337, 95, 75, 203, 235, 237, 326, 6, 150, 236, 338, 151, 209, 168, 58, 60, 208, 297, 142, 180, 292, 120, 228, 219, 142,
+    145, 330, 4, 314, 259, 209, 90, 98, 14, 294, 109, 210, 162, 204, 234, 260, 51, 316, 275, 123, 85, 200, 112, 62, 87,
+    14, 16, 263, 73, 155, 313, 10, 185, 309, 19, 49, 287, 80, 254, 2, 49, 103, 221, 214, 315, 37, 299, 72, 134, 229, 82,
+    42, 194, 338, 109, 163, 312, 38, 202, 115, 121, 216, 133, 283, 110, 324, 215, 175, 48, 23, 268, 212, 149, 242, 111,
+    41, 164, 77, 53, 19, 60, 288, 140, 164, 321, 159, 275, 211, 282, 323, 250, 2, 272, 260, 272, 27, 196, 181, 322, 187,
+    13, 203, 119, 333, 49, 289, 318, 43, 145, 264, 263, 99, 156, 324, 206, 294, 334, 169, 249, 50, 115, 246, 28, 8, 157,
+    308, 52, 240, 183, 166, 293, 2, 37, 184, 141, 337, 34, 88, 243, 133, 160, 335, 247, 300, 136, 90, 166, 285, 268, 50,
+    0, 248, 329, 113, 12, 276, 216, 89, 205, 339, 101, 172, 189, 190, 17, 46, 23, 9, 273, 3, 144, 112, 220, 238, 274, 239,
+    131, 278, 69, 102, 68, 72, 294, 122, 77, 103, 185, 71, 139, 188, 302, 167, 28, 97, 108, 153, 115, 40, 256, 173, 77,
+    117, 306, 196, 78, 165, 47, 53, 60, 309, 331, 13, 0, 291, 161, 167, 124, 152, 315, 6, 252, 142, 29, 95, 131, 143, 332,
+    254, 137, 280, 129, 196, 79, 65, 30, 197, 30, 70, 210, 200, 229, 245, 139, 337, 143, 119, 169, 38, 230, 313, 91, 141,
+    320, 70, 58, 213, 136, 100, 225, 111, 285, 326, 121, 47, 127, 326, 267, 189, 310, 232, 144, 218, 184,
+];
+const FULL_2 = [
+    67, 117, 111, 211, 282, 255, 304, 24, 110, 126, 133, 270, 89, 126, 167, 290, 240, 28, 311, 141, 69, 146, 45, 175, 306,
+    326, 80, 104, 136, 150, 132, 181, 319, 161, 332, 87, 47, 338, 119, 147, 321, 204, 245, 35, 19, 40, 294, 277, 276, 264,
+    183, 275, 24, 196, 291, 299, 190, 331, 76, 265, 42, 319, 59, 299, 57, 12, 224, 34, 215, 240, 324, 335, 252, 258, 56,
+    135, 88, 133, 28, 224, 145, 225, 139, 21, 154, 107, 214, 74, 327, 270, 242, 165, 61, 81, 192, 199, 314, 170, 99, 143,
+    210, 320, 263, 309, 253, 78, 254, 143, 226, 246, 58, 322, 248, 4, 137, 106, 101, 238, 219, 329, 238, 297, 325, 8, 303,
+    315, 24, 3, 210, 266, 25, 53, 317, 64, 83, 314, 204, 38, 30, 173, 195, 277, 72, 283, 330, 91, 228, 23, 98, 39, 144,
+    206, 300, 194, 323, 264, 324, 232, 118, 312, 280, 192, 86, 200, 284, 179, 32, 187, 268, 201, 85, 68, 304, 29, 207, 68,
+    140, 42, 267, 282, 175, 92, 299, 49, 69, 234, 141, 115, 77, 75, 127, 264, 182, 57, 141, 91, 282, 274, 300, 105, 16,
+    30, 48, 55, 67, 311, 136, 292, 314, 140, 160, 208, 266, 157, 116, 131, 250, 81, 249, 317, 173, 129, 218, 197, 167,
+    111, 190, 165, 114, 48, 82, 310, 195, 138, 2, 56, 33, 35, 121, 162, 191, 1, 131, 291, 272, 305, 117, 193, 14, 189,
+    228, 191, 159, 337, 38, 20, 221, 315, 231, 222, 6, 206, 172, 211, 336, 248, 274, 46, 243, 335, 96, 110, 237, 340, 22,
+    149, 330, 94, 244, 97, 281, 76, 20, 134, 86, 333, 34, 148, 290, 193, 259, 325, 1, 79, 189, 125, 23, 286, 336, 231, 8,
+    331, 266, 2, 18, 11, 113, 271, 68, 316, 129, 120, 3, 188, 321, 142, 93, 184, 324, 178, 284, 298, 214, 4, 113, 69, 217,
+    230, 55, 288, 184, 220, 18, 38, 16, 235, 45, 151, 22, 77, 114, 203, 234, 244, 257, 54, 205, 249, 41, 46, 74, 25, 164,
+    204, 12, 58, 99, 239, 92, 102, 59, 131, 237, 161, 330, 316, 94, 174, 233, 241, 63, 10, 301, 260, 18, 119, 151, 237,
+    296, 46, 171, 227, 160, 115, 275, 186, 338, 332, 137, 212, 293, 176, 217, 163, 151, 201, 181, 105, 333, 274, 145, 29,
+    152, 306, 44, 323, 283, 252, 139, 318, 120, 285, 103, 77, 269, 265, 160, 147, 70, 236, 167, 153, 245, 289, 168, 279,
+    49, 0, 251, 188, 172, 51, 117, 143, 122, 170, 72, 93, 246, 311, 334, 226, 187, 185, 278, 118, 305, 318, 97, 235, 254,
+    261, 95, 183, 251, 39, 72, 123, 80, 263, 8, 218, 301, 332, 89, 279, 169, 161, 278, 74, 135, 49, 148, 50, 96, 191, 340,
+    186, 119, 31, 95, 221, 99, 65, 202, 212, 37, 109, 225, 98, 169, 283, 166, 105, 318, 70, 208, 215, 220, 259, 14, 107,
+    52, 328, 232, 100, 211, 84, 261, 309, 268, 262, 64, 168, 101, 317, 340, 174, 6, 214, 54, 271, 219, 303, 278, 176, 180,
+    5, 47, 327, 107, 271, 43, 109, 33, 112, 220, 148, 20, 308, 247, 153, 37, 145, 65, 31, 130, 57, 295, 27, 159, 203, 88,
+    66, 78, 223, 207, 295, 94, 142, 183, 256, 292, 233, 40, 36, 212, 130, 48, 80, 310, 257, 127, 109, 118, 5, 316, 31,
+    257, 71, 61, 60, 262, 313, 164, 79, 294, 11, 309, 53, 250, 58, 199, 156, 236, 163, 227, 230, 208, 33, 194, 159, 138,
+    129, 87, 34, 127, 205, 246, 287, 7, 308, 39, 108, 104, 230, 199, 106, 198, 195, 255, 26, 171, 320, 269, 329, 247, 273,
+    254, 190, 120, 256, 82, 84, 229, 243, 76, 178, 79, 293, 258, 312, 123, 17, 240, 37, 44, 192, 235, 289, 296, 89, 106,
+    284, 100, 303, 14, 112, 7, 279, 12, 313, 239, 124, 239, 102, 270, 97, 297, 87, 0, 216, 0, 166, 185, 196, 268, 287,
+    241, 292, 17, 260, 286, 205, 236, 75, 138, 52, 96, 184, 52, 206, 177, 290, 21, 171, 302, 67, 338, 139, 35, 320, 294,
+    162, 297, 189, 334, 253, 121, 308, 70, 280, 187, 158, 150, 302, 213, 44, 200, 13, 45, 28, 272, 275, 244, 9, 108, 88,
+    216, 248, 250, 339, 19, 163, 249, 10, 164, 222, 181, 71, 73, 221, 310, 155, 193, 305, 133, 241, 232, 155, 158, 2, 17,
+    327, 272, 222, 103, 111, 27, 307, 122, 223, 175, 217, 247, 273, 64, 329, 288, 136, 98, 213, 125, 75, 100, 27, 29, 276,
+    86, 168, 326, 23, 198, 322, 32, 62, 300, 93, 267, 15, 62, 116, 234, 227, 328, 50, 312, 85, 147, 242, 95, 55, 207, 10,
+    122, 176, 325, 51, 215, 128, 134, 229, 146, 296, 123, 337, 228, 188, 61, 36, 281, 225, 162, 255, 124, 54, 177, 90, 66,
+    32, 73, 301, 153, 177, 334, 172, 288, 224, 295, 336, 263, 15, 285, 273, 285, 40, 209, 194, 335, 200, 26, 216, 132, 5,
+    62, 302, 331, 56, 158, 277, 276, 112, 169, 337, 219, 307, 6, 182, 262, 63, 128, 259, 41, 21, 170, 321, 65, 253, 196,
+    179, 306, 15, 50, 197, 154, 9, 47, 101, 256, 146, 173, 7, 260, 313, 149, 103, 179, 298, 281, 63, 13, 261, 1, 126, 25,
+    289, 229, 102, 218, 11, 114, 185, 202, 203, 30, 59, 36, 22, 286, 16, 157, 125, 233, 251, 287, 252, 144, 291, 82, 115,
+    81, 85, 307, 135, 90, 116, 198, 84, 152, 201, 315, 180, 41, 110, 121, 166, 128, 53, 269, 186, 90, 130, 319, 209, 91,
+    178, 60, 66, 73, 322, 3, 26, 13, 304, 174, 180, 137, 165, 328, 19, 265, 155, 42, 108, 144, 156, 4, 267, 150, 293, 142,
+    209, 92, 78, 43, 210, 43, 83, 223, 213, 242, 258, 152, 9, 156, 132, 182, 51, 243, 326, 104, 154, 333, 83, 71, 226,
+    149, 113, 238, 124, 298, 339, 134, 60, 140, 339, 280, 202, 323, 245, 157, 231, 197,
+];

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

@@ -0,0 +1,4 @@
+export * from "./error.js";
+export * from "./input.js";
+export * from "./reports.js";
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+export * from "./error.js";
+export * from "./input.js";
+export * from "./reports.js";

package/packages/jam/transition/reports/index.test.d.ts

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

package/packages/jam/transition/reports/index.test.d.ts.map

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

package/packages/jam/transition/reports/index.test.js

@@ -0,0 +1,33 @@
+import { describe, it } from "node:test";
+import { tryAsPerValidator, tryAsTimeSlot } from "#@typeberry/block";
+import { asKnownSize, HashDictionary, HashSet } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { deepEqual } from "#@typeberry/utils";
+import { ENTROPY, guaranteesAsView, initialValidators, newReports } from "./test.utils.js";
+describe("Reports - top level", () => {
+    it("should perform a transition with empty state", async () => {
+        const reports = await newReports();
+        const input = {
+            guarantees: guaranteesAsView(tinyChainSpec, []),
+            slot: tryAsTimeSlot(12),
+            newEntropy: ENTROPY,
+            recentBlocksPartialUpdate: reports.state.recentBlocks,
+            assurancesAvailAssignment: reports.state.availabilityAssignment,
+            offenders: HashSet.new(),
+            currentValidatorData: tryAsPerValidator(initialValidators(), tinyChainSpec),
+            previousValidatorData: tryAsPerValidator(initialValidators(), tinyChainSpec),
+        };
+        const res = await reports.transition(input);
+        deepEqual(res, {
+            isOk: true,
+            isError: false,
+            ok: {
+                stateUpdate: {
+                    availabilityAssignment: asKnownSize([null, null]),
+                },
+                reported: HashDictionary.new(),
+                reporters: asKnownSize([]),
+            },
+        });
+    });
+});

package/packages/jam/transition/reports/input.d.ts

@@ -0,0 +1,67 @@
+import type { HeaderHash, TimeSlot } from "#@typeberry/block";
+import type { GuaranteesExtrinsicView } from "#@typeberry/block/guarantees.js";
+import type { HashSet } from "#@typeberry/collections";
+import type { Ed25519Key } from "#@typeberry/crypto";
+import type { SafroleStateUpdate } from "#@typeberry/safrole";
+import type { AssurancesStateUpdate } from "../assurances.js";
+import type { RecentHistoryStateUpdate } from "../recent-history.js";
+/** Recently imported blocks. */
+export interface HeaderChain {
+    /** Check whether given `pastBlock` hash is part of the ancestor chain of `currentBlock` */
+    isAncestor(pastBlockSlot: TimeSlot, pastBlock: HeaderHash, currentBlock: HeaderHash): boolean;
+}
+/**
+ * Work Report is presented on-chain within `GuaranteesExtrinsic`
+ * and then it's being erasure-codec and assured (i.e. voted available
+ * by validators).
+ *
+ * After enough assurances the work-report is considered available,
+ * and the work-digests transform the state of their associated
+ * service by virtue of accumulation, covered in section 12.
+ * The report may also be timed-out, implying it may be replaced
+ * by another report without accumulation.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/138801138d01?v=0.7.2
+ */
+export type ReportsInput = {
+    /**
+     * A work-package, is transformed by validators acting as
+     * guarantors into its corresponding work-report, which
+     * similarly comprises several work-digests and then
+     * presented on-chain within the guarantees extrinsic.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/138001138401?v=0.7.2
+     */
+    guarantees: GuaranteesExtrinsicView;
+    /** Current time slot, excerpted from block header. */
+    slot: TimeSlot;
+    /** `eta_prime`: New entropy, after potential epoch transition. */
+    newEntropy: SafroleStateUpdate["entropy"];
+    /**
+     * β† - Partial update of recent blocks.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/0f56020f6b02?v=0.7.2
+     */
+    recentBlocksPartialUpdate: RecentHistoryStateUpdate["recentBlocks"];
+    /**
+     * ρ‡ - Availability assignment resulting from assurances transition
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/141302144402?v=0.7.2
+     */
+    assurancesAvailAssignment: AssurancesStateUpdate["availabilityAssignment"];
+    /**
+     * ψ′O - Ed25519 keys of validators that were proven to judge incorrectly.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/134201134201?v=0.7.2
+     */
+    offenders: HashSet<Ed25519Key>;
+    /**
+     * `κ' kappa prime` - Current validator data.
+     */
+    currentValidatorData: SafroleStateUpdate["currentValidatorData"];
+    /**
+     * `λ' lambda prime` - Previous validator data.
+     */
+    previousValidatorData: SafroleStateUpdate["previousValidatorData"];
+};
+//# sourceMappingURL=input.d.ts.map

package/packages/jam/transition/reports/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/reports/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAErE,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B,2FAA2F;IAC3F,UAAU,CAAC,aAAa,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC;CAC/F;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;;OAOG;IACH,UAAU,EAAE,uBAAuB,CAAC;IACpC,sDAAsD;IACtD,IAAI,EAAE,QAAQ,CAAC;IACf,kEAAkE;IAClE,UAAU,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAC1C;;;;OAIG;IACH,yBAAyB,EAAE,wBAAwB,CAAC,cAAc,CAAC,CAAC;IACpE;;;;OAIG;IACH,yBAAyB,EAAE,qBAAqB,CAAC,wBAAwB,CAAC,CAAC;IAC3E;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/B;;OAEG;IACH,oBAAoB,EAAE,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;IACjE;;OAEG;IACH,qBAAqB,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;CACpE,CAAC"}

package/packages/jam/transition/reports/input.js

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