@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

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

@@ -0,0 +1,50 @@
+import { type PerValidator, type TimeSlot, type WorkReportHash } from "#@typeberry/block";
+import type { GuaranteesExtrinsicView } from "#@typeberry/block/guarantees.js";
+import type { WorkPackageHash, WorkPackageInfo } from "#@typeberry/block/refine-context.js";
+import { type BytesBlob } from "#@typeberry/bytes";
+import { type HashDictionary, type KnownSizeArray } from "#@typeberry/collections";
+import type { ChainSpec } from "#@typeberry/config";
+import { type Ed25519Key, ed25519 } from "#@typeberry/crypto";
+import type { Blake2b } from "#@typeberry/hash";
+import type { SafroleStateUpdate } from "#@typeberry/safrole";
+import { type State, type StateView, type WithStateView } from "#@typeberry/state";
+import { OK, Result } from "#@typeberry/utils";
+import { ReportsError } from "./error.js";
+import type { HeaderChain, ReportsInput } from "./input.js";
+import { type GuarantorAssignment } from "./verify-credentials.js";
+export type ReportsState = Pick<State, "availabilityAssignment" | "entropy" | "getService" | "recentBlocks" | "accumulationQueue" | "recentlyAccumulated"> & WithStateView<Pick<StateView, "authPoolsView">>;
+/** Reports state update. */
+export type ReportsStateUpdate = Pick<ReportsState, "availabilityAssignment">;
+export type ReportsOutput = {
+    /** Altered state. */
+    stateUpdate: ReportsStateUpdate;
+    /**
+     * All work Packages and their segment roots reported in the extrinsic.
+     *
+     * This dictionary has the same number of items as in the input guarantees extrinsic.
+     */
+    reported: HashDictionary<WorkPackageHash, WorkPackageInfo>;
+    /** A set `M` of work package reporters. */
+    reporters: KnownSizeArray<Ed25519Key, "Guarantees * Credentials (at most `cores*3`)">;
+};
+export declare class Reports {
+    readonly chainSpec: ChainSpec;
+    readonly blake2b: Blake2b;
+    readonly state: ReportsState;
+    readonly headerChain: HeaderChain;
+    constructor(chainSpec: ChainSpec, blake2b: Blake2b, state: ReportsState, headerChain: HeaderChain);
+    transition(input: ReportsInput): Promise<Result<ReportsOutput, ReportsError>>;
+    workReportHashes(input: GuaranteesExtrinsicView, blake2b: Blake2b): KnownSizeArray<WorkReportHash, "Guarantees">;
+    verifyCredentials(input: ReportsInput, workReportHashes: KnownSizeArray<WorkReportHash, "Guarantees">): Result<ed25519.Input<BytesBlob>[], ReportsError>;
+    verifyPostSignatureChecks(input: GuaranteesExtrinsicView, assurancesAvailAssignment: ReportsInput["assurancesAvailAssignment"]): Result<typeof OK, ReportsError>;
+    verifyContextualValidity(input: ReportsInput): Result<HashDictionary<import("@typeberry/hash").OpaqueHash & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, WorkPackageInfo>, ReportsError>;
+    checkSignatures(signaturesToVerify: ed25519.Input<BytesBlob>[], signaturesValid: boolean[]): Result<OK, ReportsError>;
+    /**
+     * Get the guarantor assignment (both core and validator data)
+     * depending on the rotation.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/15df0115df01?v=0.7.2
+     */
+    getGuarantorAssignment(headerTimeSlot: TimeSlot, guaranteeTimeSlot: TimeSlot, newEntropy: SafroleStateUpdate["entropy"], currentValidatorData: SafroleStateUpdate["currentValidatorData"], previousValidatorData: SafroleStateUpdate["previousValidatorData"]): Result<PerValidator<GuarantorAssignment>, ReportsError>;
+}
+//# sourceMappingURL=reports.d.ts.map

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

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

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

@@ -0,0 +1,190 @@
+import { tryAsTimeSlot } from "#@typeberry/block";
+import { bytesBlobComparator } from "#@typeberry/bytes";
+import { asKnownSize, SortedSet } from "#@typeberry/collections";
+import { ed25519 } from "#@typeberry/crypto";
+import { AvailabilityAssignment, tryAsPerCore } from "#@typeberry/state";
+import { asOpaqueType, OK, Result } from "#@typeberry/utils";
+import { ReportsError } from "./error.js";
+import { generateCoreAssignment, rotationIndex } from "./guarantor-assignment.js";
+import { verifyReportsBasic } from "./verify-basic.js";
+import { verifyContextualValidity } from "./verify-contextual.js";
+import { verifyCredentials } from "./verify-credentials.js";
+import { verifyReportsOrder } from "./verify-order.js";
+import { verifyPostSignatureChecks } from "./verify-post-signature.js";
+export class Reports {
+    chainSpec;
+    blake2b;
+    state;
+    headerChain;
+    constructor(chainSpec, blake2b, state, headerChain) {
+        this.chainSpec = chainSpec;
+        this.blake2b = blake2b;
+        this.state = state;
+        this.headerChain = headerChain;
+    }
+    async transition(input) {
+        // verify ordering of work reports.
+        const reportsOrderResult = verifyReportsOrder(input.guarantees, this.chainSpec);
+        if (reportsOrderResult.isError) {
+            return reportsOrderResult;
+        }
+        // check some basic reports validity
+        const reportsValidity = verifyReportsBasic(input.guarantees);
+        if (reportsValidity.isError) {
+            return reportsValidity;
+        }
+        // calculate hashes of all work reports in the guarantees extrinsic (one per guarantee)
+        const workReportHashes = this.workReportHashes(input.guarantees, this.blake2b);
+        // verifying credentials for all the work reports
+        // but also slot & core assignment.
+        // returns actual signatures that need to be checked (async)
+        const signaturesToVerify = this.verifyCredentials(input, workReportHashes);
+        if (signaturesToVerify.isError) {
+            return signaturesToVerify;
+        }
+        // Actually verify signatures
+        const verifySignaturesLater = ed25519.verify(signaturesToVerify.ok);
+        // Perform rest of the work in the meantime.
+        const restResult = this.verifyPostSignatureChecks(input.guarantees, input.assurancesAvailAssignment);
+        if (restResult.isError) {
+            return restResult;
+        }
+        // confirm contextual validity
+        const contextualValidity = this.verifyContextualValidity(input);
+        if (contextualValidity.isError) {
+            return contextualValidity;
+        }
+        // check signatures correctness
+        const signaturesOk = this.checkSignatures(signaturesToVerify.ok, await verifySignaturesLater);
+        if (signaturesOk.isError) {
+            return signaturesOk;
+        }
+        /**
+         * ρ′ - equivalent to ρ‡, except where the extrinsic replaced
+         * an entry. In the case an entry is replaced, the new value
+         * includes the present time τ' allowing for the value to be
+         * replaced without respect to its availability once sufficient
+         * time has elapsed.
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/161e00165900?v=0.7.2
+         */
+        const availabilityAssignment = input.assurancesAvailAssignment.slice();
+        for (const guarantee of input.guarantees) {
+            const workReport = guarantee.view().report.materialize();
+            availabilityAssignment[workReport.coreIndex] = AvailabilityAssignment.create({
+                workReport,
+                timeout: input.slot,
+            });
+        }
+        const reporters = SortedSet.fromArray(bytesBlobComparator, signaturesToVerify.ok.map((x) => x.key)).slice();
+        if (hasAnyOffenders(reporters, input.offenders)) {
+            return Result.error(ReportsError.BannedValidator, () => "One or more reporters are banned validators");
+        }
+        return Result.ok({
+            stateUpdate: {
+                availabilityAssignment: tryAsPerCore(availabilityAssignment, this.chainSpec),
+            },
+            reported: contextualValidity.ok,
+            reporters: asKnownSize(reporters),
+        });
+    }
+    workReportHashes(input, blake2b) {
+        const workReportHashes = [];
+        for (const guarantee of input) {
+            workReportHashes.push(asOpaqueType(blake2b.hashBytes(guarantee.view().report.encoded())));
+        }
+        return asKnownSize(workReportHashes);
+    }
+    verifyCredentials(input, workReportHashes) {
+        return verifyCredentials(input.guarantees, workReportHashes, input.slot, (headerTimeSlot, guaranteeTimeSlot) => this.getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, input.newEntropy, input.currentValidatorData, input.previousValidatorData));
+    }
+    verifyPostSignatureChecks(input, assurancesAvailAssignment) {
+        const authPoolsView = this.state.view().authPoolsView();
+        return verifyPostSignatureChecks(input, assurancesAvailAssignment, authPoolsView, (id) => this.state.getService(id));
+    }
+    verifyContextualValidity(input) {
+        return verifyContextualValidity(input, this.state, this.headerChain, this.chainSpec.maxLookupAnchorAge);
+    }
+    checkSignatures(signaturesToVerify, signaturesValid) {
+        if (signaturesValid.every((isValid) => isValid)) {
+            return Result.ok(OK);
+        }
+        // we have invalid signatures, let's return nice error messages
+        const invalidKeys = signaturesValid
+            .map((isValid, idx) => {
+            if (isValid) {
+                return null;
+            }
+            return signaturesToVerify[idx].key;
+        })
+            .filter((x) => x !== null);
+        return Result.error(ReportsError.BadSignature, () => `Invalid signatures for validators with keys: ${invalidKeys.join(", ")}`);
+    }
+    /**
+     * Get the guarantor assignment (both core and validator data)
+     * depending on the rotation.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/15df0115df01?v=0.7.2
+     */
+    getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, newEntropy, currentValidatorData, previousValidatorData) {
+        const epochLength = this.chainSpec.epochLength;
+        const rotationPeriod = this.chainSpec.rotationPeriod;
+        const headerRotation = rotationIndex(headerTimeSlot, rotationPeriod);
+        const guaranteeRotation = rotationIndex(guaranteeTimeSlot, rotationPeriod);
+        const minTimeSlot = Math.max(0, headerRotation - 1) * rotationPeriod;
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/15980115be01?v=0.7.2
+        if (guaranteeTimeSlot > headerTimeSlot) {
+            return Result.error(ReportsError.FutureReportSlot, () => `Report slot is in future. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
+        }
+        if (guaranteeTimeSlot < minTimeSlot) {
+            return Result.error(ReportsError.ReportEpochBeforeLast, () => `Report slot is too old. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
+        }
+        // TODO [ToDr] [opti] below code needs cache.
+        // The `M` and `M*` sets should only be computed once per rotation.
+        // Default data for the current rotation
+        let entropy = newEntropy[2];
+        let validatorData = currentValidatorData;
+        let timeSlot = headerTimeSlot;
+        // we might need a different set of data
+        if (headerRotation > guaranteeRotation) {
+            // we can safely subtract here, because if `guaranteeRotation` is less
+            // than header rotation it must be greater than the `rotationPeriod`.
+            timeSlot = tryAsTimeSlot(headerTimeSlot - rotationPeriod);
+            // if the epoch changed, we need to take previous entropy and previous validator data.
+            if (isPreviousRotationPreviousEpoch(timeSlot, headerTimeSlot, epochLength)) {
+                entropy = newEntropy[3];
+                validatorData = previousValidatorData;
+            }
+        }
+        // we know which entropy, timeSlot and validatorData should be used,
+        // so we can compute `M` or `M*` here.
+        const coreAssignment = generateCoreAssignment(this.chainSpec, this.blake2b, entropy, timeSlot);
+        return Result.ok(zip(coreAssignment, validatorData, (core, validator) => ({
+            core,
+            ed25519: validator.ed25519,
+        })));
+    }
+}
+function isPreviousRotationPreviousEpoch(previousRotationTimeSlot, currentRotationTimeSlot, epochLength) {
+    const currentEpoch = Math.floor(currentRotationTimeSlot / epochLength);
+    const maybePreviousEpoch = Math.floor(previousRotationTimeSlot / epochLength);
+    const isPrevious = maybePreviousEpoch !== currentEpoch;
+    return isPrevious;
+}
+/**
+ * Compose two collections of the same size into a single one
+ * containing some amalgamation of both items.
+ */
+function zip(a, b, fn) {
+    return asKnownSize(a.map((aValue, index) => {
+        return fn(aValue, b[index]);
+    }));
+}
+function hasAnyOffenders(reporters, offenders) {
+    for (const key of reporters) {
+        if (offenders.has(key)) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +1,46 @@
+import { type ServiceId, type TimeSlot } from "#@typeberry/block";
+import { Credential, type GuaranteesExtrinsicView, ReportGuarantee } from "#@typeberry/block/guarantees.js";
+import { type WorkPackageHash, type WorkPackageInfo } from "#@typeberry/block/refine-context.js";
+import { WorkReport } from "#@typeberry/block/work-report.js";
+import { FixedSizeArray, HashDictionary } from "#@typeberry/collections";
+import { HashSet } from "#@typeberry/collections/hash-set.js";
+import { type ChainSpec } from "#@typeberry/config";
+import { type Ed25519Signature } from "#@typeberry/crypto";
+import { type OpaqueHash } from "#@typeberry/hash";
+import type { NotYetAccumulatedReport } from "#@typeberry/state";
+import { AvailabilityAssignment, InMemoryService, InMemoryState, ValidatorData } from "#@typeberry/state";
+import { Reports, type ReportsState } from "./reports.js";
+export declare const ENTROPY: FixedSizeArray<import("@typeberry/hash").Blake2bHash & import("@typeberry/utils").WithOpaque<"EntropyHash">, 4>;
+type WorkReportOptions = {
+    core: number;
+    authorizer?: OpaqueHash;
+    anchorBlock?: OpaqueHash;
+    stateRoot?: OpaqueHash;
+    beefyRoot?: OpaqueHash;
+    lookupAnchorSlot?: TimeSlot;
+    lookupAnchor?: OpaqueHash;
+    prerequisites?: OpaqueHash[];
+    resultSize?: number;
+};
+export declare function newWorkReport({ core, authorizer, anchorBlock, stateRoot, beefyRoot, lookupAnchorSlot, lookupAnchor, prerequisites, resultSize, }: WorkReportOptions): WorkReport;
+export declare function guaranteesAsView(spec: ChainSpec, guarantees: readonly ReportGuarantee[], { disableCredentialsRangeCheck }?: {
+    disableCredentialsRangeCheck?: boolean;
+}): GuaranteesExtrinsicView;
+export declare function newReports(options?: Parameters<typeof newReportsState>[0]): Promise<Reports>;
+export declare function newCredential(index: number, signature?: Ed25519Signature): Credential;
+type ReportStateOptions = {
+    withCoreAssignment?: boolean;
+    services?: InMemoryState["services"];
+    accumulationQueue?: NotYetAccumulatedReport[];
+    recentlyAccumulated?: HashSet<WorkPackageHash>;
+    reportedInRecentBlocks?: HashDictionary<WorkPackageHash, WorkPackageInfo>;
+    clearAvailabilityOnZero?: boolean;
+};
+declare function newReportsState({ withCoreAssignment, services, accumulationQueue, recentlyAccumulated, reportedInRecentBlocks, clearAvailabilityOnZero, }?: ReportStateOptions): ReportsState;
+export declare const initialAssignment: () => AvailabilityAssignment[];
+export declare const initialValidators: () => ValidatorData[];
+export declare const initialServices: ({ withDummyCodeHash }?: {
+    withDummyCodeHash?: boolean | undefined;
+}) => Map<ServiceId, InMemoryService>;
+export {};
+//# sourceMappingURL=test.utils.d.ts.map

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

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

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

@@ -0,0 +1,212 @@
+import { reencodeAsView, tryAsCoreIndex, tryAsPerEpochBlock, tryAsServiceGas, tryAsServiceId, tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
+import { codecKnownSizeArray, codecWithContext } from "#@typeberry/block/codec-utils.js";
+import { Credential, GuaranteesExtrinsicBounds, guaranteesExtrinsicCodec, ReportGuarantee, } from "#@typeberry/block/guarantees.js";
+import { RefineContext } from "#@typeberry/block/refine-context.js";
+import { testWorkReportHex } from "#@typeberry/block/test-helpers.js";
+import { 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 { codec, Decoder } from "#@typeberry/codec";
+import { asKnownSize, FixedSizeArray, HashDictionary } from "#@typeberry/collections";
+import { HashSet } from "#@typeberry/collections/hash-set.js";
+import { tinyChainSpec } from "#@typeberry/config";
+import { BANDERSNATCH_KEY_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES, ED25519_SIGNATURE_BYTES, } from "#@typeberry/crypto";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { AvailabilityAssignment, ENTROPY_ENTRIES, InMemoryService, InMemoryState, ServiceAccountInfo, tryAsPerCore, VALIDATOR_META_BYTES, ValidatorData, } from "#@typeberry/state";
+import { RecentBlocks } from "#@typeberry/state/recent-blocks.js";
+import { asOpaqueType } from "#@typeberry/utils";
+import { Reports } from "./reports.js";
+export const ENTROPY = getEntropy(1, 2, 3, 4);
+export function newWorkReport({ core, authorizer, anchorBlock, stateRoot, beefyRoot, lookupAnchorSlot, lookupAnchor, prerequisites, resultSize, }) {
+    const source = BytesBlob.parseBlob(testWorkReportHex());
+    const report = Decoder.decodeObject(WorkReport.Codec, source, tinyChainSpec);
+    const context = RefineContext.create({
+        anchor: anchorBlock !== undefined ? anchorBlock.asOpaque() : report.context.anchor,
+        stateRoot: stateRoot !== undefined ? stateRoot.asOpaque() : report.context.stateRoot,
+        beefyRoot: beefyRoot !== undefined ? beefyRoot.asOpaque() : report.context.beefyRoot,
+        lookupAnchor: lookupAnchor !== undefined ? lookupAnchor.asOpaque() : report.context.lookupAnchor,
+        lookupAnchorSlot: lookupAnchorSlot ?? report.context.lookupAnchorSlot,
+        prerequisites: prerequisites !== undefined ? prerequisites.map((x) => x.asOpaque()) : report.context.prerequisites,
+    });
+    return WorkReport.create({
+        workPackageSpec: report.workPackageSpec,
+        context,
+        coreIndex: tryAsCoreIndex(core),
+        authorizerHash: authorizer !== undefined ? authorizer.asOpaque() : report.authorizerHash,
+        authorizationOutput: report.authorizationOutput,
+        segmentRootLookup: report.segmentRootLookup,
+        results: FixedSizeArray.new(report.results.map((x) => WorkResult.create({
+            serviceId: x.serviceId,
+            codeHash: x.codeHash,
+            payloadHash: x.payloadHash,
+            gas: x.gas,
+            result: resultSize !== undefined ? new WorkExecResult(WorkExecResultKind.ok, Bytes.fill(resultSize, 0)) : x.result,
+            load: WorkRefineLoad.create({
+                gasUsed: tryAsServiceGas(5),
+                importedSegments: tryAsU32(0),
+                exportedSegments: tryAsU32(0),
+                extrinsicSize: tryAsU32(0),
+                extrinsicCount: tryAsU32(0),
+            }),
+        })), report.results.fixedLength),
+        authorizationGasUsed: tryAsServiceGas(1),
+    });
+}
+export function guaranteesAsView(spec, guarantees, { disableCredentialsRangeCheck = false } = {}) {
+    if (disableCredentialsRangeCheck) {
+        const fakeCodec = codecWithContext((context) => codecKnownSizeArray(codec.Class(ReportGuarantee, {
+            report: WorkReport.Codec,
+            slot: codec.u32.asOpaque(),
+            credentials: codecKnownSizeArray(Credential.Codec, {
+                minLength: 0,
+                maxLength: 5,
+            }),
+        }), {
+            minLength: 0,
+            maxLength: context.coresCount,
+            typicalLength: context.coresCount,
+        }, GuaranteesExtrinsicBounds));
+        return reencodeAsView(fakeCodec, asOpaqueType(guarantees), spec);
+    }
+    return reencodeAsView(guaranteesExtrinsicCodec, asOpaqueType(guarantees), spec);
+}
+export async function newReports(options = {}) {
+    const blake2b = await Blake2b.createHasher();
+    const state = newReportsState(options);
+    const headerChain = {
+        isAncestor() {
+            return false;
+        },
+    };
+    return new Reports(tinyChainSpec, blake2b, state, headerChain);
+}
+export function newCredential(index, signature) {
+    return Credential.create({
+        validatorIndex: tryAsValidatorIndex(index),
+        signature: signature ?? Bytes.zero(ED25519_SIGNATURE_BYTES).asOpaque(),
+    });
+}
+function newReportsState({ withCoreAssignment = false, services = new Map(), accumulationQueue = [], recentlyAccumulated = HashSet.new(), reportedInRecentBlocks = HashDictionary.new(), clearAvailabilityOnZero = false, } = {}) {
+    const spec = tinyChainSpec;
+    const coreAssignment = withCoreAssignment ? initialAssignment() : [null, null];
+    if (clearAvailabilityOnZero) {
+        coreAssignment[0] = null;
+    }
+    return InMemoryState.partial(spec, {
+        accumulationQueue: tryAsPerEpochBlock(FixedSizeArray.fill((idx) => (idx === 0 ? accumulationQueue : []), spec.epochLength), spec),
+        recentlyAccumulated: tryAsPerEpochBlock(FixedSizeArray.fill((idx) => (idx === 0 ? recentlyAccumulated : HashSet.new()), spec.epochLength), spec),
+        availabilityAssignment: tryAsPerCore(coreAssignment, spec),
+        entropy: ENTROPY,
+        authPools: getAuthPools([1, 2, 3, 4], spec),
+        recentBlocks: RecentBlocks.create({
+            blocks: asKnownSize([
+                {
+                    headerHash: Bytes.parseBytes("0x168490e085497fcb6cbe3b220e2fa32456f30c1570412edd76ccb93be9254fef", HASH_SIZE).asOpaque(),
+                    accumulationResult: Bytes.parseBytes("0x675f9e53123c83ddcdb2c1f5231f13646378aefc83837a4571d052ac80014837", HASH_SIZE).asOpaque(),
+                    postStateRoot: Bytes.zero(HASH_SIZE).asOpaque(),
+                    reported: reportedInRecentBlocks,
+                },
+                {
+                    headerHash: Bytes.parseBytes("0xbed5792b7df998e5520dfbb8c91386cf2117b2c07b7837094c79d5c0b4de9de7", HASH_SIZE).asOpaque(),
+                    accumulationResult: Bytes.parseBytes("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5", HASH_SIZE).asOpaque(),
+                    postStateRoot: Bytes.parseBytes("0x1324bad2e35946c1a95dd25380a6e9199fbd40045ae49eacfc67599cbd23cda7", HASH_SIZE).asOpaque(),
+                    reported: HashDictionary.new(),
+                },
+                {
+                    headerHash: Bytes.parseBytes("0xc0564c5e0de0942589df4343ad1956da66797240e2a2f2d6f8116b5047768986", HASH_SIZE).asOpaque(),
+                    accumulationResult: Bytes.zero(HASH_SIZE),
+                    postStateRoot: Bytes.parseBytes("0xf6967658df626fa39cbfb6014b50196d23bc2cfbfa71a7591ca7715472dd2b48", HASH_SIZE).asOpaque(),
+                    reported: HashDictionary.new(),
+                },
+            ]),
+            accumulationLog: {
+                peaks: [
+                    Bytes.zero(HASH_SIZE),
+                    Bytes.parseBytes("0xad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5", HASH_SIZE),
+                ],
+            },
+        }),
+        services,
+    });
+}
+function getAuthPools(source, spec) {
+    return tryAsPerCore([
+        asOpaqueType(source.map((x) => Bytes.fill(HASH_SIZE, x).asOpaque())),
+        asOpaqueType(source.map((x) => Bytes.fill(HASH_SIZE, x).asOpaque())),
+    ], spec);
+}
+function getEntropy(e0, e1, e2, e3) {
+    return FixedSizeArray.new([
+        Bytes.fill(HASH_SIZE, e0).asOpaque(),
+        Bytes.fill(HASH_SIZE, e1).asOpaque(),
+        Bytes.fill(HASH_SIZE, e2).asOpaque(),
+        Bytes.fill(HASH_SIZE, e3).asOpaque(),
+    ], ENTROPY_ENTRIES);
+}
+function newAvailabilityAssignment({ core, timeout }) {
+    const workReport = newWorkReport({ core });
+    return AvailabilityAssignment.create({ workReport, timeout: tryAsTimeSlot(timeout) });
+}
+function intoValidatorData({ bandersnatch, ed25519 }) {
+    return ValidatorData.create({
+        ed25519: Bytes.parseBytes(ed25519, ED25519_KEY_BYTES).asOpaque(),
+        bandersnatch: Bytes.parseBytes(bandersnatch, BANDERSNATCH_KEY_BYTES).asOpaque(),
+        bls: Bytes.zero(BLS_KEY_BYTES).asOpaque(),
+        metadata: Bytes.zero(VALIDATOR_META_BYTES),
+    });
+}
+export const initialAssignment = () => [
+    newAvailabilityAssignment({ core: 0, timeout: 11 }),
+    newAvailabilityAssignment({ core: 1, timeout: 11 }),
+];
+export const initialValidators = () => [
+    {
+        bandersnatch: "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+        ed25519: "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+    },
+    {
+        bandersnatch: "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+        ed25519: "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+    },
+    {
+        bandersnatch: "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+        ed25519: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+    },
+    {
+        bandersnatch: "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+        ed25519: "0xb3e0e096b02e2ec98a3441410aeddd78c95e27a0da6f411a09c631c0f2bea6e9",
+    },
+    {
+        bandersnatch: "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+        ed25519: "0x5c7f34a4bd4f2d04076a8c6f9060a0c8d2c6bdd082ceb3eda7df381cb260faff",
+    },
+    {
+        bandersnatch: "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+        ed25519: "0x837ce344bc9defceb0d7de7e9e9925096768b7adb4dad932e532eb6551e0ea02",
+    },
+].map(intoValidatorData);
+export const initialServices = ({ withDummyCodeHash = false } = {}) => {
+    const m = new Map();
+    const id = tryAsServiceId(129);
+    m.set(id, new InMemoryService(tryAsServiceId(129), {
+        preimages: HashDictionary.new(),
+        storage: new Map(),
+        lookupHistory: HashDictionary.new(),
+        info: ServiceAccountInfo.create({
+            codeHash: withDummyCodeHash
+                ? Bytes.fill(HASH_SIZE, 1).asOpaque()
+                : Bytes.parseBytes("0x8178abf4f459e8ed591be1f7f629168213a5ac2a487c28c0ef1a806198096c7a", HASH_SIZE).asOpaque(),
+            balance: tryAsU64(0),
+            accumulateMinGas: tryAsServiceGas(10_000),
+            onTransferMinGas: tryAsServiceGas(0),
+            storageUtilisationBytes: tryAsU64(1),
+            storageUtilisationCount: tryAsU32(1),
+            gratisStorage: tryAsU64(0),
+            created: tryAsTimeSlot(0),
+            lastAccumulation: tryAsTimeSlot(0),
+            parentService: tryAsServiceId(0),
+        }),
+    }));
+    return m;
+};

package/packages/jam/transition/reports/verify-basic.d.ts

@@ -0,0 +1,11 @@
+import type { GuaranteesExtrinsicView } from "#@typeberry/block/guarantees.js";
+import { OK, Result } from "#@typeberry/utils";
+import { ReportsError } from "./error.js";
+/**
+ * `W_R = 48 * 2**10`: The maximum total size of all output blobs in a work-report, in octets.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/41a60041aa00?v=0.6.2
+ */
+export declare const MAX_WORK_REPORT_SIZE_BYTES: number;
+export declare function verifyReportsBasic(input: GuaranteesExtrinsicView): Result<OK, ReportsError>;
+//# sourceMappingURL=verify-basic.d.ts.map

package/packages/jam/transition/reports/verify-basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-basic.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/transition/reports/verify-basic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,QAAe,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAAC,EAAE,EAAE,YAAY,CAAC,CAkD3F"}

package/packages/jam/transition/reports/verify-basic.js

@@ -0,0 +1,51 @@
+import { MAX_REPORT_DEPENDENCIES } from "#@typeberry/block/gp-constants.js";
+import { WorkExecResultKind } from "#@typeberry/block/work-result.js";
+import { OK, Result } from "#@typeberry/utils";
+import { ReportsError } from "./error.js";
+/**
+ * `W_R = 48 * 2**10`: The maximum total size of all output blobs in a work-report, in octets.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/41a60041aa00?v=0.6.2
+ */
+export const MAX_WORK_REPORT_SIZE_BYTES = 48 * 2 ** 10;
+export function verifyReportsBasic(input) {
+    for (const guarantee of input) {
+        const reportView = guarantee.view().report.view();
+        /**
+         * We limit the sum of the number of items in the
+         * segment-root lookup dictionary and the number of
+         * prerequisites to J = 8:
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/13fd0113ff01?v=0.7.2
+         */
+        const noOfPrerequisites = reportView.context.view().prerequisites.view().length;
+        const noOfSegmentRootLookups = reportView.segmentRootLookup.view().length;
+        if (noOfPrerequisites + noOfSegmentRootLookups > MAX_REPORT_DEPENDENCIES) {
+            return Result.error(ReportsError.TooManyDependencies, () => `Report at ${reportView.coreIndex.materialize()} has too many dependencies. Got ${noOfPrerequisites} + ${noOfSegmentRootLookups}, max: ${MAX_REPORT_DEPENDENCIES}`);
+        }
+        /**
+         * In order to ensure fair use of a block’s extrinsic space,
+         * work-reports are limited in the maximum total size of the
+         * successful output blobs together with the authorizer output
+         * blob, effectively limiting their overall size:
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/14a80014ab00?v=0.7.2
+         */
+        // adding is safe here, since the total-encoded size of the report
+        // is limited as well. Even though we just have a view, the size
+        // should have been verified earlier.
+        const authOutputSize = reportView.authorizationOutput.view().length;
+        let totalOutputsSize = 0;
+        for (const item of reportView.results.view()) {
+            const workItemView = item.view();
+            const result = workItemView.result.materialize();
+            if (result.kind === WorkExecResultKind.ok) {
+                totalOutputsSize += result.okBlob?.raw.length ?? 0;
+            }
+        }
+        if (authOutputSize + totalOutputsSize > MAX_WORK_REPORT_SIZE_BYTES) {
+            return Result.error(ReportsError.WorkReportTooBig, () => `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
+        }
+    }
+    return Result.ok(OK);
+}

package/packages/jam/transition/reports/verify-basic.test.d.ts

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

package/packages/jam/transition/reports/verify-basic.test.d.ts.map

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

package/packages/jam/transition/reports/verify-basic.test.js

@@ -0,0 +1,62 @@
+import { describe, it } from "node:test";
+import { tryAsTimeSlot } from "#@typeberry/block";
+import { ReportGuarantee } from "#@typeberry/block/guarantees.js";
+import { Bytes } from "#@typeberry/bytes";
+import { tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { asOpaqueType, deepEqual, OK } from "#@typeberry/utils";
+import { ReportsError } from "./error.js";
+import { guaranteesAsView, newCredential, newWorkReport } from "./test.utils.js";
+import { MAX_WORK_REPORT_SIZE_BYTES, verifyReportsBasic } from "./verify-basic.js";
+describe("Reports.verifyReportsBasic", () => {
+    it("should reject if report has too many dependencies", () => {
+        const guarantees = guaranteesAsView(tinyChainSpec, [
+            ReportGuarantee.create({
+                slot: tryAsTimeSlot(10),
+                report: newWorkReport({
+                    core: 0,
+                    prerequisites: [1, 2, 3, 4, 5, 6, 7, 8, 9].map((x) => Bytes.fill(HASH_SIZE, x)),
+                }),
+                credentials: asOpaqueType([0, 3].map((x) => newCredential(x))),
+            }),
+        ]);
+        const result = verifyReportsBasic(guarantees);
+        deepEqual(result, {
+            isOk: false,
+            isError: true,
+            error: ReportsError.TooManyDependencies,
+            details: () => "Report at 0 has too many dependencies. Got 9 + 0, max: 8",
+        });
+    });
+    it("should reject if total size is too big", () => {
+        const guarantees = guaranteesAsView(tinyChainSpec, [
+            ReportGuarantee.create({
+                slot: tryAsTimeSlot(10),
+                report: newWorkReport({ core: 0, resultSize: MAX_WORK_REPORT_SIZE_BYTES + 1 }),
+                credentials: asOpaqueType([0, 3].map((x) => newCredential(x))),
+            }),
+        ]);
+        const result = verifyReportsBasic(guarantees);
+        deepEqual(result, {
+            isOk: false,
+            isError: true,
+            error: ReportsError.WorkReportTooBig,
+            details: () => "Work report at 0 too big. Got 0 + 49153, max: 49152",
+        });
+    });
+    it("should verify correctly", () => {
+        const guarantees = guaranteesAsView(tinyChainSpec, [
+            ReportGuarantee.create({
+                slot: tryAsTimeSlot(10),
+                report: newWorkReport({ core: 0 }),
+                credentials: asOpaqueType([0, 3].map((x) => newCredential(x))),
+            }),
+        ]);
+        const result = verifyReportsBasic(guarantees);
+        deepEqual(result, {
+            isOk: true,
+            isError: false,
+            ok: OK,
+        });
+    });
+});