@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/transition/accumulate/accumulate-queue.d.ts

@@ -0,0 +1,50 @@
+import type { TimeSlot } from "#@typeberry/block";
+import type { WorkPackageHash } from "#@typeberry/block/refine-context.js";
+import type { WorkReport } from "#@typeberry/block/work-report.js";
+import { HashSet } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import { NotYetAccumulatedReport } from "#@typeberry/state";
+import type { AccumulateState } from "./accumulate-state.js";
+export declare class AccumulateQueue {
+    readonly chainSpec: ChainSpec;
+    readonly state: AccumulateState;
+    constructor(chainSpec: ChainSpec, state: AccumulateState);
+    /**
+     * Returns work reports that do not have any deps and can be accumulate immediately
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/16fa0016fa00?v=0.6.7
+     */
+    getWorkReportsToAccumulateImmediately(reports: WorkReport[]): WorkReport[];
+    /**
+     * Returns work report dependencies
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/162a01162a01?v=0.6.7
+     */
+    private getWorkReportDependencies;
+    /**
+     * Returns work reports that have some dependencies and cannot be accumulate immediately
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/162301162301?v=0.6.7
+     */
+    getWorkReportsToAccumulateLater(reports: WorkReport[]): NotYetAccumulatedReport[];
+    /**
+     * Reorders work reports based on their dependencies
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/16a40116a401?v=0.6.7
+     */
+    enqueueReports(r: NotYetAccumulatedReport[]): WorkReport[];
+    /**
+     * Returns work reports to accumulate from state
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/165d02165d02?v=0.6.7
+     */
+    getQueueFromState(slot: TimeSlot): NotYetAccumulatedReport[];
+}
+/**
+ * A fuction that removes all entries whose work-report’s hash is in the set provided as a parameter, and removes any dependencies which appear in said set.
+ * It is defined as E function in GP:
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/164501164501?v=0.6.7
+ */
+export declare function pruneQueue(reports: readonly NotYetAccumulatedReport[], processedHashes: HashSet<WorkPackageHash>): NotYetAccumulatedReport[];
+//# sourceMappingURL=accumulate-queue.d.ts.map

package/packages/jam/transition/accumulate/accumulate-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accumulate-queue.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/accumulate/accumulate-queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAe,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG7D,qBAAa,eAAe;aAER,SAAS,EAAE,SAAS;aACpB,KAAK,EAAE,eAAe;gBADtB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,eAAe;IAGxC;;;;OAIG;IACH,qCAAqC,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;IAM1E;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAMjC;;;;OAIG;IACH,+BAA+B,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,uBAAuB,EAAE;IAgBjF;;;;OAIG;IACH,cAAc,CAAC,CAAC,EAAE,uBAAuB,EAAE,GAAG,UAAU,EAAE;IAsB1D;;;;OAIG;IACH,iBAAiB,CAAC,IAAI,EAAE,QAAQ;CAMjC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,uBAAuB,EAAE,EAAE,eAAe,EAAE,OAAO,CAAC,eAAe,CAAC,6BAUhH"}

package/packages/jam/transition/accumulate/accumulate-queue.js

@@ -0,0 +1,90 @@
+import { asKnownSize, HashSet } from "#@typeberry/collections";
+import { NotYetAccumulatedReport } from "#@typeberry/state";
+import { getWorkPackageHashes } from "./accumulate-utils.js";
+export class AccumulateQueue {
+    chainSpec;
+    state;
+    constructor(chainSpec, state) {
+        this.chainSpec = chainSpec;
+        this.state = state;
+    }
+    /**
+     * Returns work reports that do not have any deps and can be accumulate immediately
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/16fa0016fa00?v=0.6.7
+     */
+    getWorkReportsToAccumulateImmediately(reports) {
+        return reports.filter((report) => {
+            return report.context.prerequisites.length === 0 && report.segmentRootLookup.length === 0;
+        });
+    }
+    /**
+     * Returns work report dependencies
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/162a01162a01?v=0.6.7
+     */
+    getWorkReportDependencies(report) {
+        return Array.from(HashSet.from(report.context.prerequisites.concat(report.segmentRootLookup.map((x) => x.workPackageHash))));
+    }
+    /**
+     * Returns work reports that have some dependencies and cannot be accumulate immediately
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/162301162301?v=0.6.7
+     */
+    getWorkReportsToAccumulateLater(reports) {
+        const history = this.state.recentlyAccumulated.flatMap((set) => Array.from(set));
+        const reportsWithDependencies = reports.filter((report) => report.context.prerequisites.length > 0 || report.segmentRootLookup.length > 0);
+        const itemsToEnqueue = reportsWithDependencies.map((report) => NotYetAccumulatedReport.create({
+            report,
+            dependencies: asKnownSize(this.getWorkReportDependencies(report)),
+        }));
+        return pruneQueue(itemsToEnqueue, HashSet.from(history));
+    }
+    /**
+     * Reorders work reports based on their dependencies
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/16a40116a401?v=0.6.7
+     */
+    enqueueReports(r) {
+        const result = [];
+        let queue = [...r];
+        while (queue.length > 0) {
+            const ready = queue.filter(({ dependencies }) => dependencies.length === 0).map(({ report }) => report);
+            if (ready.length === 0) {
+                return result;
+            }
+            result.push(...ready);
+            const readyHashes = getWorkPackageHashes(ready);
+            queue = pruneQueue(queue, readyHashes);
+        }
+        return result;
+    }
+    /**
+     * Returns work reports to accumulate from state
+     *
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/165d02165d02?v=0.6.7
+     */
+    getQueueFromState(slot) {
+        const phaseIndex = slot % this.chainSpec.epochLength;
+        const fromPhaseIndexToEnd = this.state.accumulationQueue.slice(phaseIndex);
+        const fromStartToPhaseIndex = this.state.accumulationQueue.slice(0, phaseIndex);
+        return fromPhaseIndexToEnd.concat(fromStartToPhaseIndex).flat();
+    }
+}
+/**
+ * A fuction that removes all entries whose work-report’s hash is in the set provided as a parameter, and removes any dependencies which appear in said set.
+ * It is defined as E function in GP:
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/164501164501?v=0.6.7
+ */
+export function pruneQueue(reports, processedHashes) {
+    return reports
+        .filter(({ report }) => !processedHashes.has(report.workPackageSpec.hash))
+        .map((item) => {
+        const { report, dependencies } = item;
+        return NotYetAccumulatedReport.create({
+            report,
+            dependencies: asKnownSize(dependencies.filter((dependency) => !processedHashes.has(dependency))),
+        });
+    });
+}

package/packages/jam/transition/accumulate/accumulate-queue.test.d.ts

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

package/packages/jam/transition/accumulate/accumulate-queue.test.d.ts.map

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

package/packages/jam/transition/accumulate/accumulate-queue.test.js

@@ -0,0 +1,213 @@
+import { describe, it } from "node:test";
+import { tryAsCoreIndex, tryAsPerEpochBlock, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { RefineContext, WorkPackageInfo } from "#@typeberry/block/refine-context.js";
+import { tryAsWorkItemsCount } from "#@typeberry/block/work-package.js";
+import { WorkPackageSpec, WorkReport } from "#@typeberry/block/work-report.js";
+import { WorkExecResult, WorkExecResultKind, WorkRefineLoad, WorkResult } from "#@typeberry/block/work-result.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { asKnownSize, FixedSizeArray, HashSet } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU16, tryAsU32 } from "#@typeberry/numbers";
+import { InMemoryState, NotYetAccumulatedReport, PrivilegedServices, tryAsPerCore } from "#@typeberry/state";
+import { deepEqual } from "#@typeberry/utils";
+import { AccumulateQueue, pruneQueue } from "./accumulate-queue.js";
+describe("accumulate-queue", () => {
+    const createWorkReportHash = (i) => Bytes.fill(HASH_SIZE, i).asOpaque();
+    const createWorkPackageInfo = (i) => WorkPackageInfo.create({
+        segmentTreeRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        workPackageHash: createWorkReportHash(i),
+    });
+    const createWorkReport = (workPackageHash, prerequisites = [], segmentRootLookup = []) => WorkReport.create({
+        authorizationGasUsed: tryAsServiceGas(0n),
+        authorizationOutput: BytesBlob.empty(),
+        authorizerHash: Bytes.zero(HASH_SIZE).asOpaque(),
+        context: RefineContext.create({
+            anchor: Bytes.zero(HASH_SIZE).asOpaque(),
+            beefyRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            lookupAnchor: Bytes.zero(HASH_SIZE).asOpaque(),
+            lookupAnchorSlot: tryAsTimeSlot(0),
+            prerequisites,
+            stateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+        }),
+        coreIndex: tryAsCoreIndex(0),
+        results: FixedSizeArray.new([
+            WorkResult.create({
+                codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                gas: tryAsServiceGas(0),
+                load: WorkRefineLoad.create({
+                    gasUsed: tryAsServiceGas(0),
+                    exportedSegments: tryAsU32(0),
+                    extrinsicCount: tryAsU32(0),
+                    extrinsicSize: tryAsU32(0),
+                    importedSegments: tryAsU32(0),
+                }),
+                payloadHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                result: new WorkExecResult(WorkExecResultKind.ok, BytesBlob.empty()),
+                serviceId: tryAsServiceId(0),
+            }),
+        ], tryAsWorkItemsCount(1)),
+        segmentRootLookup,
+        workPackageSpec: WorkPackageSpec.create({
+            erasureRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            exportsCount: tryAsU16(0),
+            exportsRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            hash: workPackageHash,
+            length: tryAsU32(0),
+        }),
+    });
+    const createNotAccumulatedWorkReport = (workPackageHash, dependencies = [], prerequisites = [], segmentRootLookup = []) => NotYetAccumulatedReport.create({
+        report: createWorkReport(workPackageHash, prerequisites, segmentRootLookup),
+        dependencies: asKnownSize(dependencies),
+    });
+    describe("AccumulateQueue", () => {
+        const createEmptyRecentlyAccumulated = () => {
+            const queue = new Array(tinyChainSpec.epochLength);
+            queue.fill(HashSet.new());
+            return queue;
+        };
+        const createEmptyAccumulationQueue = () => {
+            const queue = new Array(tinyChainSpec.epochLength);
+            queue.fill([]);
+            return queue;
+        };
+        const createAccumulateQueue = (recentlyAccumulated = createEmptyRecentlyAccumulated(), accumulationQueue = createEmptyAccumulationQueue()) => new AccumulateQueue(tinyChainSpec, InMemoryState.partial(tinyChainSpec, {
+            privilegedServices: PrivilegedServices.create({
+                manager: tryAsServiceId(0),
+                assigners: tryAsPerCore(new Array(tinyChainSpec.coresCount).fill(tryAsServiceId(0)), tinyChainSpec),
+                delegator: tryAsServiceId(0),
+                registrar: tryAsServiceId(0),
+                autoAccumulateServices: new Map(),
+            }),
+            recentlyAccumulated: tryAsPerEpochBlock(recentlyAccumulated, tinyChainSpec),
+            accumulationQueue: tryAsPerEpochBlock(accumulationQueue, tinyChainSpec),
+            timeslot: tryAsTimeSlot(1),
+        }));
+        describe("getWorkReportsToAccumulateImmediately", () => {
+            it("should return reports without prerequisites", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const reportsWithoutPrerequisitesAndSegments = [createWorkReport(createWorkReportHash(0))];
+                const reportsWithPrerequisites = [createWorkReport(createWorkReportHash(1), [createWorkReportHash(2)])];
+                const reports = [...reportsWithPrerequisites, ...reportsWithoutPrerequisitesAndSegments];
+                const result = accumulationQueue.getWorkReportsToAccumulateImmediately(reports);
+                deepEqual(result, reportsWithoutPrerequisitesAndSegments);
+            });
+            it("should return reports without segments", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const reportsWithoutPrerequisitesAndSegments = [createWorkReport(createWorkReportHash(0))];
+                const reportsWithSegments = [createWorkReport(createWorkReportHash(1), undefined, [createWorkPackageInfo(3)])];
+                const reports = [...reportsWithoutPrerequisitesAndSegments, ...reportsWithSegments];
+                const result = accumulationQueue.getWorkReportsToAccumulateImmediately(reports);
+                deepEqual(result, reportsWithoutPrerequisitesAndSegments);
+            });
+        });
+        describe("getWorkReportsToAccumulateLater", () => {
+            it("should return report with prerequisites", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const reportsWithoutPrerequisitesAndSegments = [createWorkReport(createWorkReportHash(0))];
+                const prerequisites = [createWorkReportHash(2)];
+                const reportsWithPrerequisites = [createWorkReport(createWorkReportHash(1), prerequisites)];
+                const reports = [...reportsWithPrerequisites, ...reportsWithoutPrerequisitesAndSegments];
+                const expectedReports = reportsWithPrerequisites.map((report) => NotYetAccumulatedReport.create({ report, dependencies: asKnownSize(prerequisites) }));
+                const result = accumulationQueue.getWorkReportsToAccumulateLater(reports);
+                deepEqual(result, expectedReports);
+            });
+            it("should return report with segments", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const segments = [createWorkPackageInfo(3)];
+                const segmentHashes = segments.map((segment) => segment.workPackageHash);
+                const reportsWithoutPrerequisitesAndSegments = [createWorkReport(createWorkReportHash(0))];
+                const reportsWithSegments = [createWorkReport(createWorkReportHash(1), undefined, segments)];
+                const reports = [...reportsWithoutPrerequisitesAndSegments, ...reportsWithSegments];
+                const expectedResult = reportsWithSegments.map((report) => NotYetAccumulatedReport.create({ report, dependencies: asKnownSize(segmentHashes) }));
+                const result = accumulationQueue.getWorkReportsToAccumulateLater(reports);
+                deepEqual(result, expectedResult);
+            });
+            it("should remove reports that were accumulate earlier", () => {
+                const dependencies = [createWorkReportHash(5)];
+                const reports = [0, 1, 2, 3].map((i) => createWorkReport(createWorkReportHash(i), dependencies));
+                const history = [0, 1].map((i) => createWorkReportHash(i));
+                const recentlyAccumulated = createEmptyRecentlyAccumulated();
+                recentlyAccumulated[0].insertAll(history);
+                const accumulationQueue = createAccumulateQueue(recentlyAccumulated);
+                const expectedReports = reports
+                    .slice(2)
+                    .map((report) => NotYetAccumulatedReport.create({ report, dependencies: asKnownSize(dependencies) }));
+                const result = accumulationQueue.getWorkReportsToAccumulateLater(reports);
+                deepEqual(result, expectedReports);
+            });
+        });
+        describe("enqueueReports", () => {
+            it("should move reports without deps to the beginning", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const dependencies = [4, 5, 6].map((i) => createWorkReportHash(i));
+                const reportsWithDeps = [1, 2, 3].map((i) => createNotAccumulatedWorkReport(createWorkReportHash(i), dependencies));
+                const reportsWithoutDeps = [4, 5, 6].map((i) => createNotAccumulatedWorkReport(createWorkReportHash(i)));
+                const reports = [...reportsWithDeps, ...reportsWithoutDeps];
+                const expectedReports = [...reportsWithoutDeps, ...reportsWithDeps].map((x) => x.report);
+                const result = accumulationQueue.enqueueReports(reports);
+                deepEqual(result, expectedReports);
+            });
+            it("should remove reports when deps cannot be met", () => {
+                const accumulationQueue = createAccumulateQueue();
+                const dependencies = [9].map((i) => createWorkReportHash(i));
+                const reportsWithDeps = [1, 2, 3].map((i) => createNotAccumulatedWorkReport(createWorkReportHash(i), dependencies));
+                const reportsWithoutDeps = [4, 5, 6].map((i) => createNotAccumulatedWorkReport(createWorkReportHash(i)));
+                const reports = [...reportsWithDeps, ...reportsWithoutDeps];
+                const expectedReports = [...reportsWithoutDeps].map((x) => x.report);
+                const result = accumulationQueue.enqueueReports(reports);
+                deepEqual(result, expectedReports);
+            });
+        });
+        describe("getQueueFromState", () => {
+            it("should split reports in state by phase index and move the second part to the beginning", () => {
+                const queue = Array.from({ length: tinyChainSpec.epochLength }, (_, i) => [
+                    createNotAccumulatedWorkReport(createWorkReportHash(i)),
+                ]);
+                const accumulateQueue = createAccumulateQueue(undefined, queue);
+                const phaseIndex = 7;
+                const slot = tryAsTimeSlot(tinyChainSpec.epochLength + phaseIndex);
+                const expectedQueue = [...queue.slice(phaseIndex), ...queue.slice(0, phaseIndex)].flat();
+                const result = accumulateQueue.getQueueFromState(slot);
+                deepEqual(result, expectedQueue);
+            });
+        });
+    });
+    describe("pruneQueue", () => {
+        it("should return the same queue when processed hash set is empty", () => {
+            const reportsToAccumulate = [
+                createNotAccumulatedWorkReport(createWorkReportHash(0)),
+                createNotAccumulatedWorkReport(createWorkReportHash(1)),
+            ];
+            const processedHashes = HashSet.new();
+            const result = pruneQueue(reportsToAccumulate, processedHashes);
+            deepEqual(result, reportsToAccumulate);
+        });
+        it("should remove report when processed hash set contains it", () => {
+            const workReportHash = createWorkReportHash(0);
+            const reportsToAccumulate = [
+                createNotAccumulatedWorkReport(workReportHash),
+                createNotAccumulatedWorkReport(createWorkReportHash(1)),
+            ];
+            const processedHashes = HashSet.from([workReportHash]);
+            const expectedReportsToAccumulate = reportsToAccumulate.slice(1);
+            const result = pruneQueue(reportsToAccumulate, processedHashes);
+            deepEqual(result, expectedReportsToAccumulate);
+        });
+        it("should remove work package hash from dependencies when processed hash set contains it", () => {
+            const dependencyHash = createWorkReportHash(0);
+            const workReportHash = createWorkReportHash(1);
+            const reportsToAccumulate = [
+                createNotAccumulatedWorkReport(workReportHash, [dependencyHash]),
+                createNotAccumulatedWorkReport(createWorkReportHash(2)),
+            ];
+            const processedHashes = HashSet.from([dependencyHash]);
+            const expectedReportsToAccumulate = [
+                createNotAccumulatedWorkReport(workReportHash),
+                ...reportsToAccumulate.slice(1),
+            ];
+            const result = pruneQueue(reportsToAccumulate, processedHashes);
+            deepEqual(result, expectedReportsToAccumulate);
+        });
+    });
+});

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

@@ -0,0 +1,28 @@
+import type { EntropyHash, ServiceId, TimeSlot } from "#@typeberry/block";
+import type { WorkReport } from "#@typeberry/block/work-report.js";
+import type { SortedArray } from "#@typeberry/collections";
+import type { OpaqueHash } from "#@typeberry/hash";
+import type { PendingTransfer, ServiceStateUpdate } from "#@typeberry/jam-host-calls";
+import type { AccumulationOutput, State } from "#@typeberry/state";
+import type { CountAndGasUsed } from "../statistics.js";
+/** `G_A`: The gas allocated to invoke a work-report’s Accumulation logic. */
+export declare const GAS_TO_INVOKE_WORK_REPORT = 10000000n;
+export type AccumulateRoot = OpaqueHash;
+export type AccumulateInput = {
+    /** time slot from header */
+    slot: TimeSlot;
+    /** List of newly available work-reports */
+    reports: WorkReport[];
+    /** eta0' (after Safrole STF) - it is not eta0 from state! */
+    entropy: EntropyHash;
+};
+export type AccumulateState = Pick<State, "timeslot" | "designatedValidatorData" | "authQueues" | "getService" | "recentlyAccumulated" | "accumulationQueue" | "privilegedServices">;
+/** Aggregated update of the accumulation state transition. */
+export type AccumulateStateUpdate = Pick<State, "timeslot"> & Partial<Pick<State, "recentlyAccumulated" | "accumulationQueue">> & ServiceStateUpdate;
+export type AccumulateResult = {
+    stateUpdate: AccumulateStateUpdate;
+    accumulationStatistics: Map<ServiceId, CountAndGasUsed>;
+    pendingTransfers: PendingTransfer[];
+    accumulationOutputLog: SortedArray<AccumulationOutput>;
+};
+//# sourceMappingURL=accumulate-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accumulate-state.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/accumulate/accumulate-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,YAAc,CAAC;AAErD,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC;AAExC,MAAM,MAAM,eAAe,GAAG;IAC5B,4BAA4B;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,2CAA2C;IAC3C,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,6DAA6D;IAC7D,OAAO,EAAE,WAAW,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,KAAK,EACH,UAAU,GACV,yBAAyB,GACzB,YAAY,GACZ,YAAY,GACZ,qBAAqB,GACrB,mBAAmB,GACnB,oBAAoB,CACvB,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,qBAAqB,GAAG,mBAAmB,CAAC,CAAC,GACjE,kBAAkB,CAAC;AAErB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAC;IACnC,sBAAsB,EAAE,GAAG,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;IACxD,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,qBAAqB,EAAE,WAAW,CAAC,kBAAkB,CAAC,CAAC;CACxD,CAAC"}

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

@@ -0,0 +1,2 @@
+/** `G_A`: The gas allocated to invoke a work-report’s Accumulation logic. */
+export const GAS_TO_INVOKE_WORK_REPORT = 10000000n;

package/packages/jam/transition/accumulate/accumulate-utils.d.ts

@@ -0,0 +1,34 @@
+import { type EntropyHash, type ServiceId, type TimeSlot } from "#@typeberry/block";
+import type { WorkPackageHash } from "#@typeberry/block/refine-context.js";
+import type { WorkReport } from "#@typeberry/block/work-report.js";
+import { HashSet } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import { type Blake2b } from "#@typeberry/hash";
+/**
+ * A function that removes duplicates but does not change order - it keeps the first occurence.
+ */
+export declare function uniquePreserveOrder<T extends number>(arr: T[]): T[];
+/**
+ * A function that returns work package hashes for given work reports
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/160102160102?v=0.6.7
+ */
+export declare function getWorkPackageHashes(reports: WorkReport[]): HashSet<WorkPackageHash>;
+type NextServiceIdInput = {
+    /** currently accumulated service */
+    serviceId: ServiceId;
+    /** `eta_0'` */
+    entropy: EntropyHash;
+    /** `H_t`: time slot of the header. */
+    timeslot: TimeSlot;
+};
+/**
+ * Generate a next service id.
+ *
+ * Please not that it does not call `check` function!
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fa9042fc304?v=0.7.2
+ */
+export declare function generateNextServiceId({ serviceId, entropy, timeslot }: NextServiceIdInput, chainSpec: ChainSpec, blake2b: Blake2b): ServiceId;
+export {};
+//# sourceMappingURL=accumulate-utils.d.ts.map

package/packages/jam/transition/accumulate/accumulate-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accumulate-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/accumulate/accumulate-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAkB,MAAM,kBAAkB,CAAC;AAEnG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,iBAAiB,CAAC;AAI1D;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAQnE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAGpF;AAED,KAAK,kBAAkB,GAAG;IACxB,oCAAoC;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,sCAAsC;IACtC,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAQF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,kBAAkB,EACpD,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,GACf,SAAS,CAkBX"}

package/packages/jam/transition/accumulate/accumulate-utils.js

@@ -0,0 +1,52 @@
+import { tryAsServiceId } from "#@typeberry/block";
+import { MIN_PUBLIC_SERVICE_INDEX } from "#@typeberry/block/gp-constants.js";
+import { codec, Encoder } from "#@typeberry/codec";
+import { HashSet } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { leBytesAsU32 } from "#@typeberry/numbers";
+import { Compatibility, GpVersion } from "#@typeberry/utils";
+/**
+ * A function that removes duplicates but does not change order - it keeps the first occurence.
+ */
+export function uniquePreserveOrder(arr) {
+    const set = new Set();
+    for (const item of arr) {
+        set.add(item);
+    }
+    return Array.from(set);
+}
+/**
+ * A function that returns work package hashes for given work reports
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/160102160102?v=0.6.7
+ */
+export function getWorkPackageHashes(reports) {
+    const workPackageHashes = reports.map((report) => report.workPackageSpec.hash);
+    return HashSet.from(workPackageHashes);
+}
+const NEXT_ID_CODEC = codec.object({
+    serviceId: codec.varU32.asOpaque(),
+    entropy: codec.bytes(HASH_SIZE).asOpaque(),
+    timeslot: codec.varU32.asOpaque(),
+});
+/**
+ * Generate a next service id.
+ *
+ * Please not that it does not call `check` function!
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/2fa9042fc304?v=0.7.2
+ */
+export function generateNextServiceId({ serviceId, entropy, timeslot }, chainSpec, blake2b) {
+    const encoded = Encoder.encodeObject(NEXT_ID_CODEC, {
+        serviceId,
+        entropy,
+        timeslot,
+    }, chainSpec);
+    const result = blake2b.hashBytes(encoded).raw.subarray(0, 4);
+    const number = leBytesAsU32(result) >>> 0;
+    const mod = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+        ? 2 ** 32 - MIN_PUBLIC_SERVICE_INDEX - 2 ** 8
+        : 2 ** 32 - 2 ** 9;
+    const offset = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? MIN_PUBLIC_SERVICE_INDEX : 2 ** 8;
+    return tryAsServiceId((number % mod) + offset);
+}

package/packages/jam/transition/accumulate/accumulate-utils.test.d.ts

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

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

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

package/packages/jam/transition/accumulate/accumulate-utils.test.js

@@ -0,0 +1,88 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { tryAsCoreIndex, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { RefineContext } from "#@typeberry/block/refine-context.js";
+import { tryAsWorkItemsCount } from "#@typeberry/block/work-package.js";
+import { WorkPackageSpec, WorkReport } from "#@typeberry/block/work-report.js";
+import { WorkExecResult, WorkExecResultKind, WorkRefineLoad, WorkResult } from "#@typeberry/block/work-result.js";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { FixedSizeArray, HashSet } from "#@typeberry/collections";
+import { tinyChainSpec } from "#@typeberry/config";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU16, tryAsU32 } from "#@typeberry/numbers";
+import { Compatibility, deepEqual, GpVersion } from "#@typeberry/utils";
+import { generateNextServiceId, getWorkPackageHashes, uniquePreserveOrder } from "./accumulate-utils.js";
+let blake2b;
+before(async () => {
+    blake2b = await Blake2b.createHasher();
+});
+describe("accumulate-utils", () => {
+    describe("uniquePreserveOrder", () => {
+        it("should remove duplicates without changing order", () => {
+            const input = [1, 1, 2, 3, 2, 3, 4, 5];
+            const expectedOutput = [1, 2, 3, 4, 5];
+            const output = uniquePreserveOrder(input);
+            deepEqual(output, expectedOutput);
+        });
+    });
+    describe("getWorkPackageHashes", () => {
+        const createWorkReportHash = (i) => Bytes.fill(HASH_SIZE, i).asOpaque();
+        const createWorkReport = (workPackageHash) => WorkReport.create({
+            authorizationGasUsed: tryAsServiceGas(0n),
+            authorizationOutput: BytesBlob.empty(),
+            authorizerHash: Bytes.zero(HASH_SIZE).asOpaque(),
+            context: RefineContext.create({
+                anchor: Bytes.zero(HASH_SIZE).asOpaque(),
+                beefyRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+                lookupAnchor: Bytes.zero(HASH_SIZE).asOpaque(),
+                lookupAnchorSlot: tryAsTimeSlot(0),
+                prerequisites: [],
+                stateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+            }),
+            coreIndex: tryAsCoreIndex(0),
+            results: FixedSizeArray.new([
+                WorkResult.create({
+                    codeHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                    gas: tryAsServiceGas(0),
+                    load: WorkRefineLoad.create({
+                        gasUsed: tryAsServiceGas(0),
+                        exportedSegments: tryAsU32(0),
+                        extrinsicCount: tryAsU32(0),
+                        extrinsicSize: tryAsU32(0),
+                        importedSegments: tryAsU32(0),
+                    }),
+                    payloadHash: Bytes.zero(HASH_SIZE).asOpaque(),
+                    result: new WorkExecResult(WorkExecResultKind.ok, BytesBlob.empty()),
+                    serviceId: tryAsServiceId(0),
+                }),
+            ], tryAsWorkItemsCount(1)),
+            segmentRootLookup: [],
+            workPackageSpec: WorkPackageSpec.create({
+                erasureRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+                exportsCount: tryAsU16(0),
+                exportsRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+                hash: workPackageHash,
+                length: tryAsU32(0),
+            }),
+        });
+        it("should map work reports to work package hashes", () => {
+            const hashes = [0, 1, 2, 3, 4, 5].map(createWorkReportHash);
+            const reports = hashes.map(createWorkReport);
+            const expectedHashSet = HashSet.from(hashes);
+            const result = getWorkPackageHashes(reports);
+            deepEqual(result, expectedHashSet);
+        });
+    });
+    describe("generateNextServiceId", () => {
+        it("should generate next service id correctly", () => {
+            const serviceId = tryAsServiceId(5);
+            const entropy = Bytes.fill(HASH_SIZE, 4).asOpaque();
+            const timeslot = tryAsTimeSlot(6);
+            const expectedServiceId = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+                ? tryAsServiceId(2596254713)
+                : tryAsServiceId(2596189433);
+            const result = generateNextServiceId({ serviceId, entropy, timeslot }, tinyChainSpec, blake2b);
+            assert.strictEqual(result, expectedServiceId);
+        });
+    });
+});