@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/jam/block/work-item.js

@@ -0,0 +1,150 @@
+import { codec } from "#@typeberry/codec";
+import { asKnownSize } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { sumU32 } from "#@typeberry/numbers";
+import { WithDebug } from "#@typeberry/utils";
+import { codecKnownSizeArray } from "./codec-utils.js";
+import { MAX_NUMBER_OF_SEGMENTS } from "./work-item-segment.js";
+/**
+ * Definition of data segment that was exported by some work package earlier
+ * and now is being imported by another work-item.
+ */
+export class ImportSpec extends WithDebug {
+    treeRoot;
+    index;
+    static Codec = codec.Class(ImportSpec, {
+        treeRoot: codec.bytes(HASH_SIZE),
+        index: codec.u16.asOpaque(),
+    });
+    static create({ treeRoot, index }) {
+        return new ImportSpec(treeRoot, index);
+    }
+    constructor(
+    /**
+     * ??: TODO [ToDr] GP seems to mention a identity of a work-package:
+     * https://graypaper.fluffylabs.dev/#/579bd12/199300199300
+     */
+    treeRoot, 
+    /** Index of the prior exported segment. */
+    index) {
+        super();
+        this.treeRoot = treeRoot;
+        this.index = index;
+    }
+}
+/** Introduced blob hashes and their lengths. */
+export class WorkItemExtrinsicSpec extends WithDebug {
+    hash;
+    len;
+    static Codec = codec.Class(WorkItemExtrinsicSpec, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        len: codec.u32,
+    });
+    static create({ hash, len }) {
+        return new WorkItemExtrinsicSpec(hash, len);
+    }
+    constructor(
+    /** The pre-image to this hash should be passed to the guarantor alongisde the work-package. */
+    hash, 
+    /** Length of the preimage identified by the hash above. */
+    len) {
+        super();
+        this.hash = hash;
+        this.len = len;
+    }
+}
+/**
+ * To encode/decode extrinsics that are specified via [`WorkItemExtrinsicSpec`]
+ * we need to know their lenghts. Hence this is created dynamically.
+ */
+export function workItemExtrinsicsCodec(workItems) {
+    const extrinsicLengths = [];
+    for (const item of workItems) {
+        for (const extrinsic of item.extrinsic) {
+            extrinsicLengths.push(extrinsic.len);
+        }
+    }
+    const sum = sumU32(...extrinsicLengths);
+    if (sum.overflow) {
+        throw new Error("Unable to create a decoder, because the length of extrinsics overflows!");
+    }
+    return codec.custom({
+        name: "WorkItemExtrinsics",
+        sizeHint: { bytes: sum.value, isExact: true },
+    }, (e, val) => {
+        for (const bytes of val) {
+            e.bytes(bytes);
+        }
+    }, (d) => {
+        const extrinsics = [];
+        for (const len of extrinsicLengths) {
+            const bytes = d.bytes(len);
+            extrinsics.push(bytes);
+        }
+        return asKnownSize(extrinsics);
+    }, (s) => s.decoder.skip(sum.value));
+}
+/**
+ * Work Item which is a part of some work package.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/1a86001a9100?v=0.7.2
+ */
+export class WorkItem extends WithDebug {
+    service;
+    codeHash;
+    payload;
+    refineGasLimit;
+    accumulateGasLimit;
+    importSegments;
+    extrinsic;
+    exportCount;
+    static Codec = codec.Class(WorkItem, {
+        service: codec.u32.asOpaque(),
+        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
+        refineGasLimit: codec.u64.asOpaque(),
+        accumulateGasLimit: codec.u64.asOpaque(),
+        exportCount: codec.u16,
+        payload: codec.blob,
+        importSegments: codecKnownSizeArray(ImportSpec.Codec, {
+            minLength: 0,
+            maxLength: MAX_NUMBER_OF_SEGMENTS,
+            typicalLength: MAX_NUMBER_OF_SEGMENTS,
+        }),
+        extrinsic: codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+    });
+    static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
+        return new WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
+    }
+    constructor(
+    /** `s`: related service */
+    service, 
+    /**
+     * `c`: code hash of the service at the time of reporting.
+     *
+     * preimage of that hash must be available from the perspective of the lookup
+     * anchor block.
+     */
+    codeHash, 
+    /** `y`: payload blob */
+    payload, 
+    /** `g`: refine execution gas limit */
+    refineGasLimit, 
+    /** `a`: accumulate execution gas limit */
+    accumulateGasLimit, 
+    /** `i`: sequence of imported data segments, which identify a prior exported segment. */
+    importSegments, 
+    /** `x`: sequence of blob hashes and lengths to be introduced in this block */
+    extrinsic, 
+    /** `e`: number of data segments exported by this work item. */
+    exportCount) {
+        super();
+        this.service = service;
+        this.codeHash = codeHash;
+        this.payload = payload;
+        this.refineGasLimit = refineGasLimit;
+        this.accumulateGasLimit = accumulateGasLimit;
+        this.importSegments = importSegments;
+        this.extrinsic = extrinsic;
+        this.exportCount = exportCount;
+    }
+}

package/packages/jam/block/work-package.d.ts

@@ -0,0 +1,78 @@
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord, type DescribedBy } from "#@typeberry/codec";
+import { FixedSizeArray } from "#@typeberry/collections";
+import { type U8 } from "#@typeberry/numbers";
+import { WithDebug } from "#@typeberry/utils";
+import type { ServiceId } from "./common.js";
+import type { CodeHash } from "./hash.js";
+import { RefineContext } from "./refine-context.js";
+import { WorkItem } from "./work-item.js";
+/** Possible number of work items in the package or results in the report. */
+/** Constrained by I=16 https://graypaper.fluffylabs.dev/#/68eaa1f/417a00417a00?v=0.6.4 */
+export type WorkItemsCount = U8;
+/** Verify the value is within the `WorkItemsCount` bounds. */
+export declare function tryAsWorkItemsCount(len: number): WorkItemsCount;
+/** Minimal number of work items in the work package or results in work report. */
+export declare const MIN_NUMBER_OF_WORK_ITEMS = 1;
+/** `I`: Maximal number of work items in the work package or results in work report. */
+export declare const MAX_NUMBER_OF_WORK_ITEMS = 16;
+/**
+ * A piece of work done within a core.
+ *
+ * `P = (j ∈ Y, h ∈ NS, u ∈ H, p ∈ Y, x ∈ X, w ∈ ⟦I⟧1∶I)
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/197000197200
+ */
+export declare class WorkPackage extends WithDebug {
+    /** `j`: simple blob acting as an authorization token */
+    readonly authorization: BytesBlob;
+    /** `h`: index of the service that hosts the authorization code */
+    readonly authCodeHost: ServiceId;
+    /** `u`: authorization code hash */
+    readonly authCodeHash: CodeHash;
+    /** `p`: authorization parametrization blob */
+    readonly parametrization: BytesBlob;
+    /** `x`: context in which the refine function should run */
+    readonly context: RefineContext;
+    /**
+     * `w`: sequence of work items.
+     *
+     * Constrained by `I=16`:
+     * https://graypaper.fluffylabs.dev/#/579bd12/416600416800
+     */
+    readonly items: FixedSizeArray<WorkItem, WorkItemsCount>;
+    static Codec: import("@typeberry/codec").Descriptor<WorkPackage, import("@typeberry/codec").ViewOf<WorkPackage, {
+        authCodeHost: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, import("@typeberry/bytes").Bytes<4>>;
+        authCodeHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, import("@typeberry/bytes").Bytes<32>>;
+        context: import("@typeberry/codec").Descriptor<RefineContext, import("@typeberry/codec").ViewOf<RefineContext, {
+            anchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            stateRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"StateRootHash">, import("@typeberry/bytes").Bytes<32>>;
+            beefyRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"BeefyHash">, import("@typeberry/bytes").Bytes<32>>;
+            lookupAnchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            lookupAnchorSlot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            prerequisites: import("@typeberry/codec").Descriptor<(import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">)[], import("@typeberry/codec").SequenceView<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>>;
+        }>>;
+        authorization: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+        parametrization: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+        items: import("@typeberry/codec").Descriptor<FixedSizeArray<WorkItem, U8>, import("@typeberry/codec").SequenceView<WorkItem, import("@typeberry/codec").ViewOf<WorkItem, {
+            service: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            codeHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, import("@typeberry/bytes").Bytes<32>>;
+            refineGasLimit: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/bytes").Bytes<8>>;
+            accumulateGasLimit: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/bytes").Bytes<8>>;
+            exportCount: import("@typeberry/codec").Descriptor<import("@typeberry/numbers").U16, import("@typeberry/bytes").Bytes<2>>;
+            payload: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+            importSegments: import("@typeberry/codec").Descriptor<readonly import("./work-item.js").ImportSpec[] & import("@typeberry/utils").WithOpaque<"Less than 2048">, import("@typeberry/codec").SequenceView<import("./work-item.js").ImportSpec, import("@typeberry/codec").ViewOf<import("./work-item.js").ImportSpec, {
+                treeRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+                index: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"Segment Index [U16]">, import("@typeberry/bytes").Bytes<2>>;
+            }>>>;
+            extrinsic: import("@typeberry/codec").Descriptor<import("./work-item.js").WorkItemExtrinsicSpec[], import("@typeberry/codec").SequenceView<import("./work-item.js").WorkItemExtrinsicSpec, import("@typeberry/codec").ViewOf<import("./work-item.js").WorkItemExtrinsicSpec, {
+                hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExtrinsicHash">, import("@typeberry/bytes").Bytes<32>>;
+                len: import("@typeberry/codec").Descriptor<import("@typeberry/numbers").U32, import("@typeberry/bytes").Bytes<4>>;
+            }>>>;
+        }>>>;
+    }>>;
+    static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }: CodecRecord<WorkPackage>): WorkPackage;
+    private constructor();
+}
+export type WorkPackageView = DescribedBy<typeof WorkPackage.Codec.View>;
+//# sourceMappingURL=work-package.d.ts.map

package/packages/jam/block/work-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-package.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/block/work-package.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAAS,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAW,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,6EAA6E;AAC7E,0FAA0F;AAC1F,MAAM,MAAM,cAAc,GAAG,EAAE,CAAC;AAEhC,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAM/D;AAED,kFAAkF;AAClF,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,uFAAuF;AACvF,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,SAAS;IAyBtC,wDAAwD;aACxC,aAAa,EAAE,SAAS;IACxC,kEAAkE;aAClD,YAAY,EAAE,SAAS;IACvC,mCAAmC;aACnB,YAAY,EAAE,QAAQ;IACtC,8CAA8C;aAC9B,eAAe,EAAE,SAAS;IAC1C,2DAA2D;aAC3C,OAAO,EAAE,aAAa;IACtC;;;;;OAKG;aACa,KAAK,EAAE,cAAc,CAAC,QAAQ,EAAE,cAAc,CAAC;IAxCjE,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUT;IAEH,MAAM,CAAC,MAAM,CAAC,EACZ,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,OAAO,EACP,KAAK,GACN,EAAE,WAAW,CAAC,WAAW,CAAC;IAI3B,OAAO;CAqBR;AAED,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC"}

package/packages/jam/block/work-package.js

@@ -0,0 +1,71 @@
+import { codec } from "#@typeberry/codec";
+import { FixedSizeArray } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { tryAsU8 } from "#@typeberry/numbers";
+import { check, WithDebug } from "#@typeberry/utils";
+import { RefineContext } from "./refine-context.js";
+import { WorkItem } from "./work-item.js";
+/** Verify the value is within the `WorkItemsCount` bounds. */
+export function tryAsWorkItemsCount(len) {
+    check `
+    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= MAX_NUMBER_OF_WORK_ITEMS}
+    WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
+  `;
+    return tryAsU8(len);
+}
+/** Minimal number of work items in the work package or results in work report. */
+export const MIN_NUMBER_OF_WORK_ITEMS = 1;
+/** `I`: Maximal number of work items in the work package or results in work report. */
+export const MAX_NUMBER_OF_WORK_ITEMS = 16;
+/**
+ * A piece of work done within a core.
+ *
+ * `P = (j ∈ Y, h ∈ NS, u ∈ H, p ∈ Y, x ∈ X, w ∈ ⟦I⟧1∶I)
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/197000197200
+ */
+export class WorkPackage extends WithDebug {
+    authorization;
+    authCodeHost;
+    authCodeHash;
+    parametrization;
+    context;
+    items;
+    static Codec = codec.Class(WorkPackage, {
+        authCodeHost: codec.u32.asOpaque(),
+        authCodeHash: codec.bytes(HASH_SIZE).asOpaque(),
+        context: RefineContext.Codec,
+        authorization: codec.blob,
+        parametrization: codec.blob,
+        items: codec.sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    });
+    static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
+        return new WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
+    }
+    constructor(
+    /** `j`: simple blob acting as an authorization token */
+    authorization, 
+    /** `h`: index of the service that hosts the authorization code */
+    authCodeHost, 
+    /** `u`: authorization code hash */
+    authCodeHash, 
+    /** `p`: authorization parametrization blob */
+    parametrization, 
+    /** `x`: context in which the refine function should run */
+    context, 
+    /**
+     * `w`: sequence of work items.
+     *
+     * Constrained by `I=16`:
+     * https://graypaper.fluffylabs.dev/#/579bd12/416600416800
+     */
+    items) {
+        super();
+        this.authorization = authorization;
+        this.authCodeHost = authCodeHost;
+        this.authCodeHash = authCodeHash;
+        this.parametrization = parametrization;
+        this.context = context;
+        this.items = items;
+    }
+}

package/packages/jam/block/work-report.d.ts

@@ -0,0 +1,138 @@
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import { FixedSizeArray } from "#@typeberry/collections";
+import { type OpaqueHash } from "#@typeberry/hash";
+import { type U16, type U32 } from "#@typeberry/numbers";
+import { WithDebug } from "#@typeberry/utils";
+import { type CoreIndex, type ServiceGas } from "./common.js";
+import { type AuthorizerHash, type ExportsRootHash, RefineContext, type WorkPackageHash, WorkPackageInfo } from "./refine-context.js";
+import { type WorkItemsCount } from "./work-package.js";
+import { WorkResult } from "./work-result.js";
+/**
+ * Details about the work package being reported on.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/130e01130e01?v=0.6.2
+ */
+export declare class WorkPackageSpec extends WithDebug {
+    /** `h`: The hash of the work package. */
+    readonly hash: WorkPackageHash;
+    /** `l`: Auditable work-bundle length. */
+    readonly length: U32;
+    /** `u`: The root hash of the erasure coding merkle tree of that work package. */
+    readonly erasureRoot: OpaqueHash;
+    /** `e`: The root hash of all data segments exported by this work package. */
+    readonly exportsRoot: ExportsRootHash;
+    /** `n`: Number of segments exported by this work package. */
+    readonly exportsCount: U16;
+    static Codec: import("@typeberry/codec").Descriptor<WorkPackageSpec, import("@typeberry/codec").ViewOf<WorkPackageSpec, {
+        hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>;
+        length: import("@typeberry/codec").Descriptor<U32, import("@typeberry/bytes").Bytes<4>>;
+        erasureRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+        exportsRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExportsRootHash">, import("@typeberry/bytes").Bytes<32>>;
+        exportsCount: import("@typeberry/codec").Descriptor<U16, import("@typeberry/bytes").Bytes<2>>;
+    }>>;
+    static create({ hash, length, erasureRoot, exportsRoot, exportsCount }: CodecRecord<WorkPackageSpec>): WorkPackageSpec;
+    private constructor();
+}
+/**
+ * A report of execution of some work package.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/13bb0113c301?v=0.7.2
+ */
+export declare class WorkReport extends WithDebug {
+    /** `s`: Work package specification. */
+    readonly workPackageSpec: WorkPackageSpec;
+    /** `c`: Refinement context. */
+    readonly context: RefineContext;
+    /** *`c`*: Core index on which the work is done. */
+    readonly coreIndex: CoreIndex;
+    /** *`a`*: Hash of the authorizer. */
+    readonly authorizerHash: AuthorizerHash;
+    /** `o`: Authorization output. */
+    readonly authorizationOutput: BytesBlob;
+    /** `l`: Segment-root lookup
+     * In GP segment-root lookup is a dictionary but dictionary and var-len sequence are equal from codec perspective
+     * https://graypaper.fluffylabs.dev/#/579bd12/13ab0013ad00
+     */
+    readonly segmentRootLookup: readonly WorkPackageInfo[];
+    /** `r`: The results of evaluation of each of the items in the work package. */
+    readonly results: FixedSizeArray<WorkResult, WorkItemsCount>;
+    /** *`g`*: Gas used during authorization. */
+    readonly authorizationGasUsed: ServiceGas;
+    static Codec: import("@typeberry/codec").Descriptor<WorkReport, import("@typeberry/codec").ViewOf<WorkReport, {
+        workPackageSpec: import("@typeberry/codec").Descriptor<WorkPackageSpec, import("@typeberry/codec").ViewOf<WorkPackageSpec, {
+            hash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>;
+            length: import("@typeberry/codec").Descriptor<U32, import("@typeberry/bytes").Bytes<4>>;
+            erasureRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+            exportsRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExportsRootHash">, import("@typeberry/bytes").Bytes<32>>;
+            exportsCount: import("@typeberry/codec").Descriptor<U16, import("@typeberry/bytes").Bytes<2>>;
+        }>>;
+        context: import("@typeberry/codec").Descriptor<RefineContext, import("@typeberry/codec").ViewOf<RefineContext, {
+            anchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            stateRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"StateRootHash">, import("@typeberry/bytes").Bytes<32>>;
+            beefyRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"BeefyHash">, import("@typeberry/bytes").Bytes<32>>;
+            lookupAnchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+            lookupAnchorSlot: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            prerequisites: import("@typeberry/codec").Descriptor<(import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">)[], import("@typeberry/codec").SequenceView<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>>;
+        }>>;
+        coreIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"CoreIndex[u16]">, U32>;
+        authorizerHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"AuthorizerHash">, import("@typeberry/bytes").Bytes<32>>;
+        authorizationGasUsed: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/numbers").U64>;
+        authorizationOutput: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+        segmentRootLookup: import("@typeberry/codec").Descriptor<readonly WorkPackageInfo[], import("@typeberry/codec").SequenceView<WorkPackageInfo, import("@typeberry/codec").ViewOf<WorkPackageInfo, {
+            workPackageHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"WorkPackageHash">, import("@typeberry/bytes").Bytes<32>>;
+            segmentTreeRoot: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"ExportsRootHash">, import("@typeberry/bytes").Bytes<32>>;
+        }>>>;
+        results: import("@typeberry/codec").Descriptor<FixedSizeArray<WorkResult, import("@typeberry/numbers").U8>, import("@typeberry/codec").SequenceView<WorkResult, import("@typeberry/codec").ViewOf<WorkResult, {
+            serviceId: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">, import("@typeberry/bytes").Bytes<4>>;
+            codeHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"CodeHash">, import("@typeberry/bytes").Bytes<32>>;
+            payloadHash: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
+            gas: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/bytes").Bytes<8>>;
+            result: import("@typeberry/codec").Descriptor<import("./work-result.js").WorkExecResult, {
+                kind: import("./work-result.js").WorkExecResultKind.ok;
+                okBlob: BytesBlob;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.outOfGas;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.panic;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.incorrectNumberOfExports;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.digestTooBig;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.badCode;
+            } | {
+                kind: import("./work-result.js").WorkExecResultKind.codeOversize;
+            }>;
+            load: import("@typeberry/codec").Descriptor<import("./work-result.js").WorkRefineLoad, import("@typeberry/codec").ViewOf<import("./work-result.js").WorkRefineLoad, {
+                gasUsed: import("@typeberry/codec").Descriptor<bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">, import("@typeberry/numbers").U64>;
+                importedSegments: import("@typeberry/codec").Descriptor<U32, U32>;
+                extrinsicCount: import("@typeberry/codec").Descriptor<U32, U32>;
+                extrinsicSize: import("@typeberry/codec").Descriptor<U32, U32>;
+                exportedSegments: import("@typeberry/codec").Descriptor<U32, U32>;
+            }>>;
+        }>>>;
+    }>>;
+    static create({ workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed, }: CodecRecord<WorkReport>): WorkReport;
+    protected constructor(
+    /** `s`: Work package specification. */
+    workPackageSpec: WorkPackageSpec, 
+    /** `c`: Refinement context. */
+    context: RefineContext, 
+    /** *`c`*: Core index on which the work is done. */
+    coreIndex: CoreIndex, 
+    /** *`a`*: Hash of the authorizer. */
+    authorizerHash: AuthorizerHash, 
+    /** `o`: Authorization output. */
+    authorizationOutput: BytesBlob, 
+    /** `l`: Segment-root lookup
+     * In GP segment-root lookup is a dictionary but dictionary and var-len sequence are equal from codec perspective
+     * https://graypaper.fluffylabs.dev/#/579bd12/13ab0013ad00
+     */
+    segmentRootLookup: readonly WorkPackageInfo[], 
+    /** `r`: The results of evaluation of each of the items in the work package. */
+    results: FixedSizeArray<WorkResult, WorkItemsCount>, 
+    /** *`g`*: Gas used during authorization. */
+    authorizationGasUsed: ServiceGas);
+}
+//# sourceMappingURL=work-report.d.ts.map

package/packages/jam/block/work-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-report.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/block/work-report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAmB,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAkB,MAAM,aAAa,CAAC;AAC9E,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,aAAa,EACb,KAAK,eAAe,EACpB,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAc1C,yCAAyC;aACzB,IAAI,EAAE,eAAe;IACrC,yCAAyC;aACzB,MAAM,EAAE,GAAG;IAC3B,iFAAiF;aACjE,WAAW,EAAE,UAAU;IACvC,6EAA6E;aAC7D,WAAW,EAAE,eAAe;IAC5C,6DAA6D;aAC7C,YAAY,EAAE,GAAG;IAtBnC,MAAM,CAAC,KAAK;;;;;;QAMT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,EAAE,WAAW,CAAC,eAAe,CAAC;IAIpG,OAAO;CAcR;AAED;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,SAAS;IA8CrC,uCAAuC;aACvB,eAAe,EAAE,eAAe;IAChD,+BAA+B;aACf,OAAO,EAAE,aAAa;IACtC,mDAAmD;aACnC,SAAS,EAAE,SAAS;IACpC,qCAAqC;aACrB,cAAc,EAAE,cAAc;IAC9C,iCAAiC;aACjB,mBAAmB,EAAE,SAAS;IAC9C;;;OAGG;aACa,iBAAiB,EAAE,SAAS,eAAe,EAAE;IAC7D,+EAA+E;aAC/D,OAAO,EAAE,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC;IACnE,4CAA4C;aAC5B,oBAAoB,EAAE,UAAU;IA/DlD,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoBT;IAEH,MAAM,CAAC,MAAM,CAAC,EACZ,eAAe,EACf,OAAO,EACP,SAAS,EACT,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,OAAO,EACP,oBAAoB,GACrB,EAAE,WAAW,CAAC,UAAU,CAAC;IAa1B,SAAS;IACP,uCAAuC;IACvB,eAAe,EAAE,eAAe;IAChD,+BAA+B;IACf,OAAO,EAAE,aAAa;IACtC,mDAAmD;IACnC,SAAS,EAAE,SAAS;IACpC,qCAAqC;IACrB,cAAc,EAAE,cAAc;IAC9C,iCAAiC;IACjB,mBAAmB,EAAE,SAAS;IAC9C;;;OAGG;IACa,iBAAiB,EAAE,SAAS,eAAe,EAAE;IAC7D,+EAA+E;IAC/D,OAAO,EAAE,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC;IACnE,4CAA4C;IAC5B,oBAAoB,EAAE,UAAU;CAInD"}

package/packages/jam/block/work-report.js

@@ -0,0 +1,112 @@
+import { codec } from "#@typeberry/codec";
+import { FixedSizeArray } from "#@typeberry/collections";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { isU16, tryAsU32 } from "#@typeberry/numbers";
+import { WithDebug } from "#@typeberry/utils";
+import { tryAsCoreIndex } from "./common.js";
+import { RefineContext, WorkPackageInfo, } from "./refine-context.js";
+import { tryAsWorkItemsCount } from "./work-package.js";
+import { WorkResult } from "./work-result.js";
+/**
+ * Details about the work package being reported on.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/130e01130e01?v=0.6.2
+ */
+export class WorkPackageSpec extends WithDebug {
+    hash;
+    length;
+    erasureRoot;
+    exportsRoot;
+    exportsCount;
+    static Codec = codec.Class(WorkPackageSpec, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        length: codec.u32,
+        erasureRoot: codec.bytes(HASH_SIZE),
+        exportsRoot: codec.bytes(HASH_SIZE).asOpaque(),
+        exportsCount: codec.u16,
+    });
+    static create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
+        return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
+    }
+    constructor(
+    /** `h`: The hash of the work package. */
+    hash, 
+    /** `l`: Auditable work-bundle length. */
+    length, 
+    /** `u`: The root hash of the erasure coding merkle tree of that work package. */
+    erasureRoot, 
+    /** `e`: The root hash of all data segments exported by this work package. */
+    exportsRoot, 
+    /** `n`: Number of segments exported by this work package. */
+    exportsCount) {
+        super();
+        this.hash = hash;
+        this.length = length;
+        this.erasureRoot = erasureRoot;
+        this.exportsRoot = exportsRoot;
+        this.exportsCount = exportsCount;
+    }
+}
+/**
+ * A report of execution of some work package.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/13bb0113c301?v=0.7.2
+ */
+export class WorkReport extends WithDebug {
+    workPackageSpec;
+    context;
+    coreIndex;
+    authorizerHash;
+    authorizationOutput;
+    segmentRootLookup;
+    results;
+    authorizationGasUsed;
+    static Codec = codec.Class(WorkReport, {
+        workPackageSpec: WorkPackageSpec.Codec,
+        context: RefineContext.Codec,
+        coreIndex: codec.varU32.convert((o) => tryAsU32(o), (i) => {
+            if (!isU16(i)) {
+                throw new Error(`Core index exceeds U16: ${i}`);
+            }
+            return tryAsCoreIndex(i);
+        }),
+        authorizerHash: codec.bytes(HASH_SIZE).asOpaque(),
+        authorizationGasUsed: codec.varU64.asOpaque(),
+        authorizationOutput: codec.blob,
+        segmentRootLookup: codec.readonlyArray(codec.sequenceVarLen(WorkPackageInfo.Codec)),
+        results: codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    });
+    static create({ workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed, }) {
+        return new WorkReport(workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed);
+    }
+    constructor(
+    /** `s`: Work package specification. */
+    workPackageSpec, 
+    /** `c`: Refinement context. */
+    context, 
+    /** *`c`*: Core index on which the work is done. */
+    coreIndex, 
+    /** *`a`*: Hash of the authorizer. */
+    authorizerHash, 
+    /** `o`: Authorization output. */
+    authorizationOutput, 
+    /** `l`: Segment-root lookup
+     * In GP segment-root lookup is a dictionary but dictionary and var-len sequence are equal from codec perspective
+     * https://graypaper.fluffylabs.dev/#/579bd12/13ab0013ad00
+     */
+    segmentRootLookup, 
+    /** `r`: The results of evaluation of each of the items in the work package. */
+    results, 
+    /** *`g`*: Gas used during authorization. */
+    authorizationGasUsed) {
+        super();
+        this.workPackageSpec = workPackageSpec;
+        this.context = context;
+        this.coreIndex = coreIndex;
+        this.authorizerHash = authorizerHash;
+        this.authorizationOutput = authorizationOutput;
+        this.segmentRootLookup = segmentRootLookup;
+        this.results = results;
+        this.authorizationGasUsed = authorizationGasUsed;
+    }
+}

package/packages/jam/block/work-report.test.d.ts

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

package/packages/jam/block/work-report.test.d.ts.map

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

package/packages/jam/block/work-report.test.js

@@ -0,0 +1,19 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Encoder } from "#@typeberry/codec";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { tryAsServiceGas } from "./common.js";
+import { WorkRefineLoad } from "./work-result.js";
+describe("WorkReport", () => {
+    it("should encode work refine load", () => {
+        const load = WorkRefineLoad.create({
+            gasUsed: tryAsServiceGas(0),
+            importedSegments: tryAsU32(0),
+            exportedSegments: tryAsU32(0),
+            extrinsicCount: tryAsU32(0),
+            extrinsicSize: tryAsU32(0),
+        });
+        const encoded = Encoder.encodeObject(WorkRefineLoad.Codec, load);
+        assert.deepStrictEqual(encoded.toString(), "0x0000000000");
+    });
+});