@typeberry/lib 0.5.0-d7595f1 → 0.5.1-1dda9d6

package/{index.js → index.mjs}

@@ -1581,7 +1581,7 @@ function addSizeHints(a, b) {
     };
 }
 const DEFAULT_START_LENGTH = 512; // 512B
-const MAX_LENGTH$1 = 10 * 1024 * 1024; // 10MB
+const MAX_LENGTH$1 = 20 * 1024 * 1024; // 20MB
 /**
  * JAM encoder.
  */
@@ -1934,7 +1934,7 @@ class Encoder {
             if (options.silent) {
                 return;
             }
-            throw new Error(`The encoded size would reach the maximum of ${MAX_LENGTH$1}.`);
+            throw new Error(`The encoded size (${newLength}) would reach the maximum of ${MAX_LENGTH$1}.`);
         }
         if (newLength > this.destination.length) {
             // we can try to resize the underlying buffer
@@ -2379,6 +2379,48 @@ const pair = (a, b) => {
 };
 /** Custom encoding / decoding logic. */
 const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
+/** Tagged union type encoding. */
+const union = (name, variants) => {
+    const keys = Object.keys(variants).map(Number);
+    const variantMap = Object.fromEntries(keys.map((key, idx) => [key, idx]));
+    const indexToKey = Object.fromEntries(keys.map((key, idx) => [idx, key]));
+    // Calculate size hint as the minimum variant size + index size
+    const minVariantSize = Math.max(...keys.map((key) => variants[key].sizeHint.bytes));
+    const sizeHint = {
+        bytes: 1 + minVariantSize, // varU32 index + smallest variant
+        isExact: false,
+    };
+    const encode = (e, x) => {
+        const idx = variantMap[x.kind];
+        if (idx === undefined) {
+            throw new Error(`Unknown variant type: ${x.kind} for ${name}`);
+        }
+        e.varU32(tryAsU32(idx));
+        const codec = variants[x.kind];
+        // I'm sorry but I can't figure out a better typing here :)
+        codec.encode(e, x);
+    };
+    const decode = (d) => {
+        const idx = d.varU32();
+        const kind = indexToKey[idx];
+        if (kind === undefined) {
+            throw new Error(`Unknown variant index: ${idx} for ${name}`);
+        }
+        const codec = variants[kind];
+        const value = codec.decode(d);
+        return { kind, ...value };
+    };
+    const skip = (s) => {
+        const idx = s.decoder.varU32();
+        const kind = indexToKey[idx];
+        if (kind === undefined) {
+            throw new Error(`Unknown variant index: ${idx} for ${name}`);
+        }
+        const codec = variants[kind];
+        codec.skip(s);
+    };
+    return Descriptor.new(name, sizeHint, encode, decode, skip);
+};
 /** Choose a descriptor depending on the encoding/decoding context. */
 const select = ({ name, sizeHint, }, chooser) => {
     const Self = chooser(null);
@@ -2554,24 +2596,59 @@ var descriptors = /*#__PURE__*/Object.freeze({
   u32: u32,
   u64: u64,
   u8: u8,
+  union: union,
   varU32: varU32,
   varU64: varU64
 });
 
+const codec = descriptors;
+
 var index$x = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  Class: Class,
   Decoder: Decoder,
   Descriptor: Descriptor,
   Encoder: Encoder,
   EndOfDataError: EndOfDataError,
   ObjectView: ObjectView,
   SequenceView: SequenceView,
+  TYPICAL_DICTIONARY_LENGTH: TYPICAL_DICTIONARY_LENGTH,
   ViewField: ViewField,
   addSizeHints: addSizeHints,
-  codec: descriptors,
+  bitVecFixLen: bitVecFixLen,
+  bitVecVarLen: bitVecVarLen,
+  blob: blob,
+  bool: bool,
+  bytes: bytes,
+  codec: codec,
+  custom: custom,
   decodeVariableLengthExtraBytes: decodeVariableLengthExtraBytes,
+  dictionary: dictionary,
+  forEachDescriptor: forEachDescriptor,
+  i16: i16,
+  i24: i24,
+  i32: i32,
+  i64: i64,
+  i8: i8,
+  nothing: nothing,
+  object: object,
+  optional: optional,
+  pair: pair,
+  readonlyArray: readonlyArray,
+  select: select,
+  sequenceFixLen: sequenceFixLen,
+  sequenceVarLen: sequenceVarLen,
+  string: string,
   tryAsExactBytes: tryAsExactBytes,
-  validateLength: validateLength
+  u16: u16,
+  u24: u24,
+  u32: u32,
+  u64: u64,
+  u8: u8,
+  union: union,
+  validateLength: validateLength,
+  varU32: varU32,
+  varU64: varU64
 });
 
 //#region rolldown:runtime
@@ -5782,7 +5859,7 @@ function codecWithContext(chooser) {
     const defaultContext = fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return select({
+    return codec.select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -5809,9 +5886,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, asKnownSize);
+        return codec.readonlyArray(codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, asKnownSize);
     }
-    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, asKnownSize);
+    return codec.readonlyArray(codec.sequenceVarLen(val, options)).convert(seeThrough, asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -5820,7 +5897,7 @@ const codecFixedSizeArray = (val, len) => {
             throw new Error(`[${val.name}] Invalid size of fixed-size array. Got ${actual}, expected: ${len}`);
         }
     };
-    return sequenceFixLen(val, len).convert((i) => {
+    return codec.sequenceFixLen(val, len).convert((i) => {
         checkLength(i.length);
         return i;
     }, (o) => {
@@ -5829,7 +5906,7 @@ const codecFixedSizeArray = (val, len) => {
     });
 };
 /** Codec for a hash-dictionary. */
-const codecHashDictionary = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
+const codecHashDictionary = (value, extractKey, { typicalLength = codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
     return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
@@ -5883,13 +5960,13 @@ class AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = Class(AvailabilityAssurance, {
-        anchor: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(AvailabilityAssurance, {
+        anchor: codec.bytes(HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return bitVecFixLen(context.coresCount);
+            return codec.bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+        validatorIndex: codec.u16.asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ anchor, bitfield, validatorIndex, signature }) {
         return new AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
@@ -5974,11 +6051,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = Class(Fault, {
-        workReportHash: bytes(HASH_SIZE).asOpaque(),
-        wasConsideredValid: bool,
-        key: bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec.Class(Fault, {
+        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
+        wasConsideredValid: codec.bool,
+        key: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, wasConsideredValid, key, signature }) {
         return new Fault(workReportHash, wasConsideredValid, key, signature);
@@ -6006,10 +6083,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = Class(Culprit, {
-        workReportHash: bytes(HASH_SIZE).asOpaque(),
-        key: bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec.Class(Culprit, {
+        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
+        key: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, key, signature }) {
         return new Culprit(workReportHash, key, signature);
@@ -6034,10 +6111,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = Class(Judgement, {
-        isWorkReportValid: bool,
-        index: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec.Class(Judgement, {
+        isWorkReportValid: codec.bool,
+        index: codec.u16.asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ isWorkReportValid, index, signature }) {
         return new Judgement(isWorkReportValid, index, signature);
@@ -6066,11 +6143,12 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = Class(Verdict, {
-        workReportHash: bytes(HASH_SIZE).asOpaque(),
-        votesEpoch: u32.asOpaque(),
+    static Codec = codec.Class(Verdict, {
+        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
+        votesEpoch: codec.u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+            return codec
+                .readonlyArray(codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
                 .convert(seeThrough, asKnownSize);
         }),
     });
@@ -6112,10 +6190,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = Class(DisputesExtrinsic, {
-        verdicts: sequenceVarLen(Verdict.Codec),
-        culprits: sequenceVarLen(Culprit.Codec),
-        faults: sequenceVarLen(Fault.Codec),
+    static Codec = codec.Class(DisputesExtrinsic, {
+        verdicts: codec.sequenceVarLen(Verdict.Codec),
+        culprits: codec.sequenceVarLen(Culprit.Codec),
+        faults: codec.sequenceVarLen(Fault.Codec),
     });
     static create({ verdicts, culprits, faults }) {
         return new DisputesExtrinsic(verdicts, culprits, faults);
@@ -6166,9 +6244,9 @@ var disputes = /*#__PURE__*/Object.freeze({
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = Class(WorkPackageInfo, {
-        workPackageHash: bytes(HASH_SIZE).asOpaque(),
-        segmentTreeRoot: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(WorkPackageInfo, {
+        workPackageHash: codec.bytes(HASH_SIZE).asOpaque(),
+        segmentTreeRoot: codec.bytes(HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -6196,13 +6274,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = Class(RefineContext, {
-        anchor: bytes(HASH_SIZE).asOpaque(),
-        stateRoot: bytes(HASH_SIZE).asOpaque(),
-        beefyRoot: bytes(HASH_SIZE).asOpaque(),
-        lookupAnchor: bytes(HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: u32.asOpaque(),
-        prerequisites: sequenceVarLen(bytes(HASH_SIZE).asOpaque()),
+    static Codec = codec.Class(RefineContext, {
+        anchor: codec.bytes(HASH_SIZE).asOpaque(),
+        stateRoot: codec.bytes(HASH_SIZE).asOpaque(),
+        beefyRoot: codec.bytes(HASH_SIZE).asOpaque(),
+        lookupAnchor: codec.bytes(HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: codec.u32.asOpaque(),
+        prerequisites: codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()),
     });
     static create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -6254,9 +6332,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = Class(ImportSpec, {
-        treeRoot: bytes(HASH_SIZE),
-        index: u16.asOpaque(),
+    static Codec = codec.Class(ImportSpec, {
+        treeRoot: codec.bytes(HASH_SIZE),
+        index: codec.u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -6278,9 +6356,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = Class(WorkItemExtrinsicSpec, {
-        hash: bytes(HASH_SIZE).asOpaque(),
-        len: u32,
+    static Codec = codec.Class(WorkItemExtrinsicSpec, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        len: codec.u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -6310,7 +6388,7 @@ function workItemExtrinsicsCodec(workItems) {
     if (sum.overflow) {
         throw new Error("Unable to create a decoder, because the length of extrinsics overflows!");
     }
-    return custom({
+    return codec.custom({
         name: "WorkItemExtrinsics",
         sizeHint: { bytes: sum.value, isExact: true },
     }, (e, val) => {
@@ -6340,19 +6418,19 @@ class WorkItem extends WithDebug {
     importSegments;
     extrinsic;
     exportCount;
-    static Codec = Class(WorkItem, {
-        service: u32.asOpaque(),
-        codeHash: bytes(HASH_SIZE).asOpaque(),
-        refineGasLimit: u64.asOpaque(),
-        accumulateGasLimit: u64.asOpaque(),
-        exportCount: u16,
-        payload: blob,
+    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: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+        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);
@@ -6425,13 +6503,13 @@ class WorkPackage extends WithDebug {
     parametrization;
     context;
     items;
-    static Codec = Class(WorkPackage, {
-        authCodeHost: u32.asOpaque(),
-        authCodeHash: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(WorkPackage, {
+        authCodeHost: codec.u32.asOpaque(),
+        authCodeHash: codec.bytes(HASH_SIZE).asOpaque(),
         context: RefineContext.Codec,
-        authorization: blob,
-        parametrization: blob,
-        items: sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        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);
@@ -6494,30 +6572,22 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = custom({
-        name: "WorkExecResult",
-        sizeHint: { bytes: 1, isExact: false },
-    }, (e, x) => {
-        e.varU32(tryAsU32(x.kind));
-        if (x.kind === WorkExecResultKind.ok && x.okBlob !== null) {
-            e.bytesBlob(x.okBlob);
-        }
-    }, (d) => {
-        const kind = d.varU32();
-        if (kind === WorkExecResultKind.ok) {
-            const blob = d.bytesBlob();
-            return new WorkExecResult(kind, blob);
-        }
-        if (kind > WorkExecResultKind.codeOversize) {
-            throw new Error(`Invalid WorkExecResultKind: ${kind}`);
-        }
-        return new WorkExecResult(kind);
-    }, (s) => {
-        const kind = s.decoder.varU32();
-        if (kind === WorkExecResultKind.ok) {
-            s.bytesBlob();
-        }
-    });
+    static Codec = codec
+        .union("WorkExecResult", {
+        [WorkExecResultKind.ok]: codec.object({ okBlob: codec.blob }),
+        [WorkExecResultKind.outOfGas]: codec.object({}),
+        [WorkExecResultKind.panic]: codec.object({}),
+        [WorkExecResultKind.incorrectNumberOfExports]: codec.object({}),
+        [WorkExecResultKind.digestTooBig]: codec.object({}),
+        [WorkExecResultKind.badCode]: codec.object({}),
+        [WorkExecResultKind.codeOversize]: codec.object({}),
+    })
+        .convert((x) => {
+        if (x.kind === WorkExecResultKind.ok) {
+            return { kind: WorkExecResultKind.ok, okBlob: x.okBlob ?? BytesBlob.empty() };
+        }
+        return { kind: x.kind };
+    }, (x) => new WorkExecResult(x.kind, x.kind === WorkExecResultKind.ok ? x.okBlob : null));
     constructor(
     /** The execution result tag. */
     kind, 
@@ -6541,12 +6611,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = Class(WorkRefineLoad, {
-        gasUsed: varU64.asOpaque(),
-        importedSegments: varU32,
-        extrinsicCount: varU32,
-        extrinsicSize: varU32,
-        exportedSegments: varU32,
+    static Codec = codec.Class(WorkRefineLoad, {
+        gasUsed: codec.varU64.asOpaque(),
+        importedSegments: codec.varU32,
+        extrinsicCount: codec.varU32,
+        extrinsicSize: codec.varU32,
+        exportedSegments: codec.varU32,
     });
     static create({ gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments, }) {
         return new WorkRefineLoad(gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments);
@@ -6582,11 +6652,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = Class(WorkResult, {
-        serviceId: u32.asOpaque(),
-        codeHash: bytes(HASH_SIZE).asOpaque(),
-        payloadHash: bytes(HASH_SIZE),
-        gas: u64.asOpaque(),
+    static Codec = codec.Class(WorkResult, {
+        serviceId: codec.u32.asOpaque(),
+        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
+        payloadHash: codec.bytes(HASH_SIZE),
+        gas: codec.u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -6651,12 +6721,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = Class(WorkPackageSpec, {
-        hash: bytes(HASH_SIZE).asOpaque(),
-        length: u32,
-        erasureRoot: bytes(HASH_SIZE),
-        exportsRoot: bytes(HASH_SIZE).asOpaque(),
-        exportsCount: u16,
+    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);
@@ -6694,20 +6764,20 @@ class WorkReport extends WithDebug {
     segmentRootLookup;
     results;
     authorizationGasUsed;
-    static Codec = Class(WorkReport, {
+    static Codec = codec.Class(WorkReport, {
         workPackageSpec: WorkPackageSpec.Codec,
         context: RefineContext.Codec,
-        coreIndex: varU32.convert((o) => tryAsU32(o), (i) => {
+        coreIndex: codec.varU32.convert((o) => tryAsU32(o), (i) => {
             if (!isU16(i)) {
                 throw new Error(`Core index exceeds U16: ${i}`);
             }
             return tryAsCoreIndex(i);
         }),
-        authorizerHash: bytes(HASH_SIZE).asOpaque(),
-        authorizationGasUsed: varU64.asOpaque(),
-        authorizationOutput: blob,
-        segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
-        results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        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);
@@ -6755,9 +6825,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = Class(Credential, {
-        validatorIndex: u16.asOpaque(),
-        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec.Class(Credential, {
+        validatorIndex: codec.u16.asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ validatorIndex, signature }) {
         return new Credential(validatorIndex, signature);
@@ -6775,15 +6845,15 @@ class Credential extends WithDebug {
 /**
  * Tuple of work-report, a credential and it's corresponding timeslot.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/147102149102
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/15df00150301?v=0.7.2
  */
 class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = Class(ReportGuarantee, {
+    static Codec = codec.Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: u32.asOpaque(),
+        slot: codec.u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -6803,7 +6873,7 @@ class ReportGuarantee extends WithDebug {
      * validator index and a signature.
      * Credentials must be ordered by their validator index.
      *
-     * https://graypaper.fluffylabs.dev/#/579bd12/14b90214bb02
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/152b01152d01?v=0.7.2
      */
     credentials) {
         super();
@@ -6835,10 +6905,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = Class(SignedTicket, {
+    static Codec = codec.Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: u8.asOpaque(),
-        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: codec.u8.asOpaque(),
+        signature: codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -6857,10 +6927,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = Class(Ticket, {
-        id: bytes(HASH_SIZE),
+    static Codec = codec.Class(Ticket, {
+        id: codec.bytes(HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: u8.asOpaque(),
+        attempt: codec.u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -6902,9 +6972,9 @@ var tickets = /*#__PURE__*/Object.freeze({
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = Class(ValidatorKeys, {
-        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
+    static Codec = codec.Class(ValidatorKeys, {
+        bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
     });
     static create({ bandersnatch, ed25519 }) {
         return new ValidatorKeys(bandersnatch, ed25519);
@@ -6921,7 +6991,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = Class(TicketsMarker, {
+    static Codec = codec.Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -6943,9 +7013,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = Class(EpochMarker, {
-        entropy: bytes(HASH_SIZE).asOpaque(),
-        ticketsEntropy: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(EpochMarker, {
+        entropy: codec.bytes(HASH_SIZE).asOpaque(),
+        ticketsEntropy: codec.bytes(HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -6982,17 +7052,17 @@ const encodeUnsealedHeader = (view) => {
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/0c66000c7200?v=0.7.2
  */
 class Header extends WithDebug {
-    static Codec = Class(Header, {
-        parentHeaderHash: bytes(HASH_SIZE).asOpaque(),
-        priorStateRoot: bytes(HASH_SIZE).asOpaque(),
-        extrinsicHash: bytes(HASH_SIZE).asOpaque(),
-        timeSlotIndex: u32.asOpaque(),
-        epochMarker: optional(EpochMarker.Codec),
-        ticketsMarker: optional(TicketsMarker.Codec),
-        bandersnatchBlockAuthorIndex: u16.asOpaque(),
-        entropySource: bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-        offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
-        seal: bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    static Codec = codec.Class(Header, {
+        parentHeaderHash: codec.bytes(HASH_SIZE).asOpaque(),
+        priorStateRoot: codec.bytes(HASH_SIZE).asOpaque(),
+        extrinsicHash: codec.bytes(HASH_SIZE).asOpaque(),
+        timeSlotIndex: codec.u32.asOpaque(),
+        epochMarker: codec.optional(EpochMarker.Codec),
+        ticketsMarker: codec.optional(TicketsMarker.Codec),
+        bandersnatchBlockAuthorIndex: codec.u16.asOpaque(),
+        entropySource: codec.bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+        offendersMarker: codec.sequenceVarLen(codec.bytes(ED25519_KEY_BYTES).asOpaque()),
+        seal: codec.bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
     });
     static create(h) {
         return Object.assign(Header.empty(), h);
@@ -7047,8 +7117,8 @@ class Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = Class(HeaderViewWithHash, {
-        hash: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(HeaderViewWithHash, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
         data: Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -7066,9 +7136,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = Class(Preimage, {
-        requester: u32.asOpaque(),
-        blob: blob,
+    static Codec = codec.Class(Preimage, {
+        requester: codec.u32.asOpaque(),
+        blob: codec.blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -7083,7 +7153,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = codec.sequenceVarLen(Preimage.Codec);
 
 var preimage = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -7104,7 +7174,7 @@ class Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = Class(Extrinsic, {
+    static Codec = codec.Class(Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -7157,7 +7227,7 @@ class Extrinsic extends WithDebug {
 class Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = Class(Block, {
+    static Codec = codec.Class(Block, {
         header: Header.Codec,
         extrinsic: Extrinsic.Codec,
     });
@@ -7578,8 +7648,9 @@ const workExecResultFromJson = json.object({
     panic: json.optional(json.fromAny(() => null)),
     bad_code: json.optional(json.fromAny(() => null)),
     code_oversize: json.optional(json.fromAny(() => null)),
+    output_oversize: json.optional(json.fromAny(() => null)),
 }, (val) => {
-    const { ok, out_of_gas, panic, bad_code, code_oversize } = val;
+    const { ok, out_of_gas, panic, bad_code, code_oversize, output_oversize } = val;
     if (ok !== undefined) {
         return new WorkExecResult(tryAsU32(WorkExecResultKind.ok), ok);
     }
@@ -7595,6 +7666,9 @@ const workExecResultFromJson = json.object({
     if (code_oversize === null) {
         return new WorkExecResult(tryAsU32(WorkExecResultKind.codeOversize));
     }
+    if (output_oversize === null) {
+        return new WorkExecResult(tryAsU32(WorkExecResultKind.digestTooBig));
+    }
     throw new Error("Invalid WorkExecResult");
 });
 const workRefineLoadFromJson = json.object({
@@ -7859,14 +7933,14 @@ var chain_spec$1 = {
 		ff000000000000000000000000000000000000000000000000000000000000: "00d1b097b4410b3a63446d7c57d093972a9744fcd2d74f4a5e2ec163610e6d6327ffffffffffffffff0a000000000000000a000000000000003418020000000000ffffffffffffffff04000000000000000000000000000000"
 	}
 };
-var database_base_path$1 = "./database";
+var database_base_path = "./database";
 var defaultConfig = {
 	$schema: $schema$1,
 	version: version$2,
 	flavor: flavor$1,
 	authorship: authorship$1,
 	chain_spec: chain_spec$1,
-	database_base_path: database_base_path$1
+	database_base_path: database_base_path
 };
 
 var $schema = "https://fluffylabs.dev/typeberry/schemas/config-v1.schema.json";
@@ -7904,14 +7978,12 @@ var chain_spec = {
 		ff000000000000000000000000000000000000000000000000000000000000: "00d1b097b4410b3a63446d7c57d093972a9744fcd2d74f4a5e2ec163610e6d6327ffffffffffffffff0a000000000000000a000000000000003418020000000000ffffffffffffffff04000000000000000000000000000000"
 	}
 };
-var database_base_path = "./database";
 var devConfig = {
 	$schema: $schema,
 	version: version$1,
 	flavor: flavor,
 	authorship: authorship,
-	chain_spec: chain_spec,
-	database_base_path: database_base_path
+	chain_spec: chain_spec
 };
 
 const configs = {
@@ -8653,9 +8725,9 @@ function legacyServiceNested(serviceId, hash) {
 class AccumulationOutput {
     serviceId;
     output;
-    static Codec = Class(AccumulationOutput, {
-        serviceId: u32.asOpaque(),
-        output: bytes(HASH_SIZE),
+    static Codec = codec.Class(AccumulationOutput, {
+        serviceId: codec.u32.asOpaque(),
+        output: codec.bytes(HASH_SIZE),
     });
     static create(a) {
         return new AccumulationOutput(a.serviceId, a.output);
@@ -8704,8 +8776,6 @@ const W_B = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 13_791_360 : 13_7
 const W_C = 4_000_000;
 /** `W_M`: The maximum number of imports in a work-package. */
 const W_M = 3_072;
-/** `W_R`: The maximum total size of all output blobs in a work-report, in octets. */
-const W_R = 49_152;
 /** `W_T`: The size of a transfer memo in octets. */
 const W_T = 128;
 /** `W_M`: The maximum number of exports in a work-package. */
@@ -8733,9 +8803,9 @@ const MAX_REPORT_DEPENDENCIES = 8;
 class NotYetAccumulatedReport extends WithDebug {
     report;
     dependencies;
-    static Codec = Class(NotYetAccumulatedReport, {
+    static Codec = codec.Class(NotYetAccumulatedReport, {
         report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(bytes(HASH_SIZE).asOpaque(), {
+        dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque(), {
             typicalLength: MAX_REPORT_DEPENDENCIES / 2,
             maxLength: MAX_REPORT_DEPENDENCIES,
             minLength: 0,
@@ -8762,7 +8832,7 @@ class NotYetAccumulatedReport extends WithDebug {
         this.dependencies = dependencies;
     }
 }
-const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(sequenceVarLen(NotYetAccumulatedReport.Codec)));
+const accumulationQueueCodec = codecPerEpochBlock(codec.readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
 
 /** Check if given array has correct length before casting to the opaque type. */
 function tryAsPerCore(array, spec) {
@@ -8787,9 +8857,9 @@ const codecPerCore = (val) => codecWithContext((context) => {
 class AvailabilityAssignment extends WithDebug {
     workReport;
     timeout;
-    static Codec = Class(AvailabilityAssignment, {
+    static Codec = codec.Class(AvailabilityAssignment, {
         workReport: WorkReport.Codec,
-        timeout: u32.asOpaque(),
+        timeout: codec.u32.asOpaque(),
     });
     static create({ workReport, timeout }) {
         return new AvailabilityAssignment(workReport, timeout);
@@ -8804,20 +8874,20 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignment.Codec));
+const availabilityAssignmentsCodec = codecPerCore(codec.optional(AvailabilityAssignment.Codec));
 
 /** `O`: Maximal authorization pool size. */
 const MAX_AUTH_POOL_SIZE = O;
 /** `Q`: Size of the authorization queue. */
 const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(bytes(HASH_SIZE).asOpaque(), {
+const authPoolsCodec = codecPerCore(codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque(), {
     minLength: 0,
     maxLength: MAX_AUTH_POOL_SIZE,
     typicalLength: MAX_AUTH_POOL_SIZE,
 }));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
-const sortedSetCodec = () => readonlyArray(sequenceVarLen(bytes(HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => codec.readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -8832,7 +8902,7 @@ class DisputesRecords {
     badSet;
     wonkySet;
     punishSet;
-    static Codec = Class(DisputesRecords, {
+    static Codec = codec.Class(DisputesRecords, {
         goodSet: workReportsSortedSetCodec,
         badSet: workReportsSortedSetCodec,
         wonkySet: workReportsSortedSetCodec,
@@ -8897,10 +8967,10 @@ class BlockState extends WithDebug {
     accumulationResult;
     postStateRoot;
     reported;
-    static Codec = Class(BlockState, {
-        headerHash: bytes(HASH_SIZE).asOpaque(),
-        accumulationResult: bytes(HASH_SIZE),
-        postStateRoot: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(BlockState, {
+        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
+        accumulationResult: codec.bytes(HASH_SIZE),
+        postStateRoot: codec.bytes(HASH_SIZE).asOpaque(),
         reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
     static create({ headerHash, accumulationResult, postStateRoot, reported }) {
@@ -8930,14 +9000,14 @@ class BlockState extends WithDebug {
 class RecentBlocks extends WithDebug {
     blocks;
     accumulationLog;
-    static Codec = Class(RecentBlocks, {
+    static Codec = codec.Class(RecentBlocks, {
         blocks: codecKnownSizeArray(BlockState.Codec, {
             minLength: 0,
             maxLength: MAX_RECENT_HISTORY,
             typicalLength: MAX_RECENT_HISTORY,
         }),
-        accumulationLog: object({
-            peaks: readonlyArray(sequenceVarLen(optional(bytes(HASH_SIZE)))),
+        accumulationLog: codec.object({
+            peaks: codec.readonlyArray(codec.sequenceVarLen(codec.optional(codec.bytes(HASH_SIZE)))),
         }),
     });
     static empty() {
@@ -8965,7 +9035,7 @@ class RecentBlocks extends WithDebug {
     }
 }
 
-const recentlyAccumulatedCodec = codecPerEpochBlock(sequenceVarLen(bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+const recentlyAccumulatedCodec = codecPerEpochBlock(codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
 
 /**
  * Fixed size of validator metadata.
@@ -8983,11 +9053,11 @@ class ValidatorData extends WithDebug {
     ed25519;
     bls;
     metadata;
-    static Codec = Class(ValidatorData, {
-        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: bytes(VALIDATOR_META_BYTES),
+    static Codec = codec.Class(ValidatorData, {
+        bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        bls: codec.bytes(BLS_KEY_BYTES).asOpaque(),
+        metadata: codec.bytes(VALIDATOR_META_BYTES),
     });
     static create({ ed25519, bandersnatch, bls, metadata }) {
         return new ValidatorData(bandersnatch, ed25519, bls, metadata);
@@ -9015,46 +9085,26 @@ var SafroleSealingKeysKind;
     SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
     SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
 })(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSealingKeysData extends WithDebug {
     kind;
     keys;
     tickets;
     static Codec = codecWithContext((context) => {
-        return custom({
-            name: "SafroleSealingKeys",
-            sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
-        }, (e, x) => {
-            e.varU32(tryAsU32(x.kind));
+        const keysCodec = codec
+            .sequenceFixLen(codecBandersnatchKey, context.epochLength)
+            .convert((keys) => Array.from(keys), (keys) => tryAsPerEpochBlock(keys, context));
+        const ticketsCodec = codec.sequenceFixLen(Ticket.Codec, context.epochLength).convert((tickets) => Array.from(tickets), (tickets) => tryAsPerEpochBlock(tickets, context));
+        return codec
+            .union("SafroleSealingKeys", {
+            [SafroleSealingKeysKind.Keys]: codec.object({ keys: keysCodec }),
+            [SafroleSealingKeysKind.Tickets]: codec.object({ tickets: ticketsCodec }),
+        })
+            .convert((x) => x, (x) => {
             if (x.kind === SafroleSealingKeysKind.Keys) {
-                e.sequenceFixLen(codecBandersnatchKey, x.keys);
+                return SafroleSealingKeysData.keys(x.keys);
             }
-            else {
-                e.sequenceFixLen(Ticket.Codec, x.tickets);
-            }
-        }, (d) => {
-            const epochLength = context.epochLength;
-            const kind = d.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
-                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        }, (s) => {
-            const kind = s.decoder.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-                return;
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                s.sequenceFixLen(Ticket.Codec, context.epochLength);
-                return;
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+            return SafroleSealingKeysData.tickets(x.tickets);
         });
     });
     static keys(keys) {
@@ -9075,11 +9125,11 @@ class SafroleData {
     epochRoot;
     sealingKeySeries;
     ticketsAccumulator;
-    static Codec = Class(SafroleData, {
+    static Codec = codec.Class(SafroleData, {
         nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
         sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
+        ticketsAccumulator: codec.readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
     });
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
         return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
@@ -9157,17 +9207,17 @@ class ServiceAccountInfo extends WithDebug {
     created;
     lastAccumulation;
     parentService;
-    static Codec = Class(ServiceAccountInfo, {
-        codeHash: bytes(HASH_SIZE).asOpaque(),
-        balance: u64,
-        accumulateMinGas: u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: u64,
-        gratisStorage: u64,
-        storageUtilisationCount: u32,
-        created: u32.convert((x) => x, tryAsTimeSlot),
-        lastAccumulation: u32.convert((x) => x, tryAsTimeSlot),
-        parentService: u32.convert((x) => x, tryAsServiceId),
+    static Codec = codec.Class(ServiceAccountInfo, {
+        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
+        balance: codec.u64,
+        accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+        onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+        storageUtilisationBytes: codec.u64,
+        gratisStorage: codec.u64,
+        storageUtilisationCount: codec.u32,
+        created: codec.u32.convert((x) => x, tryAsTimeSlot),
+        lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+        parentService: codec.u32.convert((x) => x, tryAsServiceId),
     });
     static create(a) {
         return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
@@ -9223,9 +9273,9 @@ class ServiceAccountInfo extends WithDebug {
 class PreimageItem extends WithDebug {
     hash;
     blob;
-    static Codec = Class(PreimageItem, {
-        hash: bytes(HASH_SIZE).asOpaque(),
-        blob: blob,
+    static Codec = codec.Class(PreimageItem, {
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        blob: codec.blob,
     });
     static create({ hash, blob }) {
         return new PreimageItem(hash, blob);
@@ -9239,9 +9289,9 @@ class PreimageItem extends WithDebug {
 class StorageItem extends WithDebug {
     key;
     value;
-    static Codec = Class(StorageItem, {
-        key: blob.convert((i) => i, (o) => asOpaqueType(o)),
-        value: blob,
+    static Codec = codec.Class(StorageItem, {
+        key: codec.blob.convert((i) => i, (o) => asOpaqueType(o)),
+        value: codec.blob,
     });
     static create({ key, value }) {
         return new StorageItem(key, value);
@@ -9295,13 +9345,13 @@ class ValidatorStatistics {
     preImagesSize;
     guarantees;
     assurances;
-    static Codec = Class(ValidatorStatistics, {
-        blocks: u32,
-        tickets: u32,
-        preImages: u32,
-        preImagesSize: u32,
-        guarantees: u32,
-        assurances: u32,
+    static Codec = codec.Class(ValidatorStatistics, {
+        blocks: codec.u32,
+        tickets: codec.u32,
+        preImages: codec.u32,
+        preImagesSize: codec.u32,
+        guarantees: codec.u32,
+        assurances: codec.u32,
     });
     static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
         return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
@@ -9331,9 +9381,9 @@ class ValidatorStatistics {
         return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-const codecVarU16 = varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
+const codecVarU16 = codec.varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
 /** Encode/decode unsigned gas. */
-const codecVarGas = varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
+const codecVarGas = codec.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
  * Single core statistics.
  * Updated per block, based on incoming work reports (`w`).
@@ -9350,14 +9400,14 @@ class CoreStatistics {
     extrinsicCount;
     bundleSize;
     gasUsed;
-    static Codec = Class(CoreStatistics, {
-        dataAvailabilityLoad: varU32,
+    static Codec = codec.Class(CoreStatistics, {
+        dataAvailabilityLoad: codec.varU32,
         popularity: codecVarU16,
         imports: codecVarU16,
         extrinsicCount: codecVarU16,
-        extrinsicSize: varU32,
+        extrinsicSize: codec.varU32,
         exports: codecVarU16,
-        bundleSize: varU32,
+        bundleSize: codec.varU32,
         gasUsed: codecVarGas,
     });
     static create(v) {
@@ -9416,31 +9466,31 @@ class ServiceStatistics {
     onTransfersCount;
     onTransfersGasUsed;
     static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: Class(ServiceStatistics, {
+        fallback: codec.Class(ServiceStatistics, {
             providedCount: codecVarU16,
-            providedSize: varU32,
-            refinementCount: varU32,
+            providedSize: codec.varU32,
+            refinementCount: codec.varU32,
             refinementGasUsed: codecVarGas,
             imports: codecVarU16,
             extrinsicCount: codecVarU16,
-            extrinsicSize: varU32,
+            extrinsicSize: codec.varU32,
             exports: codecVarU16,
-            accumulateCount: varU32,
+            accumulateCount: codec.varU32,
             accumulateGasUsed: codecVarGas,
-            onTransfersCount: varU32,
+            onTransfersCount: codec.varU32,
             onTransfersGasUsed: codecVarGas,
         }),
         versions: {
-            [GpVersion.V0_7_1]: Class(ServiceStatistics, {
+            [GpVersion.V0_7_1]: codec.Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: varU32,
-                refinementCount: varU32,
+                providedSize: codec.varU32,
+                refinementCount: codec.varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: varU32,
+                extrinsicSize: codec.varU32,
                 exports: codecVarU16,
-                accumulateCount: varU32,
+                accumulateCount: codec.varU32,
                 accumulateGasUsed: codecVarGas,
                 onTransfersCount: ignoreValueWithDefault(tryAsU32(0)),
                 onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
@@ -9501,11 +9551,11 @@ class StatisticsData {
     previous;
     cores;
     services;
-    static Codec = Class(StatisticsData, {
+    static Codec = codec.Class(StatisticsData, {
         current: codecPerValidator(ValidatorStatistics.Codec),
         previous: codecPerValidator(ValidatorStatistics.Codec),
         cores: codecPerCore(CoreStatistics.Codec),
-        services: dictionary(u32.asOpaque(), ServiceStatistics.Codec, {
+        services: codec.dictionary(codec.u32.asOpaque(), ServiceStatistics.Codec, {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -9587,14 +9637,14 @@ class PrivilegedServices {
     assigners;
     autoAccumulateServices;
     /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = Class(PrivilegedServices, {
-        manager: u32.asOpaque(),
-        assigners: codecPerCore(u32.asOpaque()),
-        delegator: u32.asOpaque(),
+    static Codec = codec.Class(PrivilegedServices, {
+        manager: codec.u32.asOpaque(),
+        assigners: codecPerCore(codec.u32.asOpaque()),
+        delegator: codec.u32.asOpaque(),
         registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? u32.asOpaque()
+            ? codec.u32.asOpaque()
             : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: dictionary(u32.asOpaque(), u64.asOpaque(), {
+        autoAccumulateServices: codec.dictionary(codec.u32.asOpaque(), codec.u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -10239,15 +10289,15 @@ class InMemoryState extends WithDebug {
         });
     }
 }
-const serviceEntriesCodec = object({
-    storageKeys: sequenceVarLen(blob.convert((i) => i, (o) => asOpaqueType(o))),
-    preimages: sequenceVarLen(bytes(HASH_SIZE).asOpaque()),
-    lookupHistory: sequenceVarLen(object({
-        hash: bytes(HASH_SIZE).asOpaque(),
-        length: u32,
+const serviceEntriesCodec = codec.object({
+    storageKeys: codec.sequenceVarLen(codec.blob.convert((i) => i, (o) => asOpaqueType(o))),
+    preimages: codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()),
+    lookupHistory: codec.sequenceVarLen(codec.object({
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        length: codec.u32,
     })),
 });
-const serviceDataCodec = dictionary(u32.asOpaque(), serviceEntriesCodec, {
+const serviceDataCodec = codec.dictionary(codec.u32.asOpaque(), serviceEntriesCodec, {
     sortKeys: (a, b) => a - b,
 });
 
@@ -10350,7 +10400,7 @@ var serialize;
     /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
     serialize.entropy = {
         key: stateKeys.index(StateKeyIdx.Eta),
-        Codec: codecFixedSizeArray(bytes(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        Codec: codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
         extract: (s) => s.entropy,
     };
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
@@ -10380,7 +10430,7 @@ var serialize;
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
     serialize.timeslot = {
         key: stateKeys.index(StateKeyIdx.Tau),
-        Codec: u32.asOpaque(),
+        Codec: codec.u32.asOpaque(),
         extract: (s) => s.timeslot,
     };
     /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
@@ -10410,7 +10460,7 @@ var serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        Codec: sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
+        Codec: codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
         extract: (s) => s.accumulationOutputLog,
     };
     /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
@@ -10433,7 +10483,7 @@ var serialize;
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
         key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
-        Codec: readonlyArray(sequenceVarLen(u32)),
+        Codec: codec.readonlyArray(codec.sequenceVarLen(codec.u32)),
     });
 })(serialize || (serialize = {}));
 /**
@@ -11527,7 +11577,7 @@ function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsA
 
 const TYPICAL_STATE_ITEMS = 50;
 const TYPICAL_STATE_ITEM_LEN = 50;
-const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE), blob));
+const stateEntriesSequenceCodec = codec.sequenceVarLen(codec.pair(codec.bytes(TRUNCATED_HASH_SIZE), codec.blob));
 /**
  * Full, in-memory state represented as serialized entries dictionary.
  *
@@ -11535,7 +11585,7 @@ const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE)
  */
 class StateEntries {
     dictionary;
-    static Codec = custom({
+    static Codec = codec.custom({
         name: "StateEntries",
         sizeHint: {
             isExact: false,
@@ -12355,10 +12405,10 @@ class Version extends WithDebug {
     major;
     minor;
     patch;
-    static Codec = Class(Version, {
-        major: u8,
-        minor: u8,
-        patch: u8,
+    static Codec = codec.Class(Version, {
+        major: codec.u8,
+        minor: codec.u8,
+        patch: codec.u8,
     });
     static tryFromString(str) {
         const parse = (v) => tryAsU8(Number(v));
@@ -12410,12 +12460,12 @@ class PeerInfo extends WithDebug {
     jamVersion;
     appVersion;
     name;
-    static Codec = Class(PeerInfo, {
-        fuzzVersion: u8,
-        features: u32,
+    static Codec = codec.Class(PeerInfo, {
+        fuzzVersion: codec.u8,
+        features: codec.u32,
         jamVersion: Version.Codec,
         appVersion: Version.Codec,
-        name: string,
+        name: codec.string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
         return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
@@ -12438,9 +12488,9 @@ class PeerInfo extends WithDebug {
 class AncestryItem extends WithDebug {
     slot;
     headerHash;
-    static Codec = Class(AncestryItem, {
-        slot: u32.asOpaque(),
-        headerHash: bytes(HASH_SIZE).asOpaque(),
+    static Codec = codec.Class(AncestryItem, {
+        slot: codec.u32.asOpaque(),
+        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
     });
     static create({ slot, headerHash }) {
         return new AncestryItem(slot, headerHash);
@@ -12460,9 +12510,9 @@ class AncestryItem extends WithDebug {
 class KeyValue extends WithDebug {
     key;
     value;
-    static Codec = Class(KeyValue, {
-        key: bytes(TRUNCATED_HASH_SIZE),
-        value: blob,
+    static Codec = codec.Class(KeyValue, {
+        key: codec.bytes(TRUNCATED_HASH_SIZE),
+        value: codec.blob,
     });
     static create({ key, value }) {
         return new KeyValue(key, value);
@@ -12474,12 +12524,12 @@ class KeyValue extends WithDebug {
     }
 }
 /** State ::= SEQUENCE OF KeyValue */
-const stateCodec = sequenceVarLen(KeyValue.Codec);
+const stateCodec = codec.sequenceVarLen(KeyValue.Codec);
 /**
  * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
  * Empty when `feature-ancestry` is not supported by both parties
  */
-const ancestryCodec = sequenceVarLen(AncestryItem.Codec, {
+const ancestryCodec = codec.sequenceVarLen(AncestryItem.Codec, {
     minLength: 0,
     maxLength: 24,
 });
@@ -12494,7 +12544,7 @@ class Initialize extends WithDebug {
     header;
     keyvals;
     ancestry;
-    static Codec = Class(Initialize, {
+    static Codec = codec.Class(Initialize, {
         header: Header.Codec,
         keyvals: stateCodec,
         ancestry: ancestryCodec,
@@ -12510,14 +12560,14 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const getStateCodec = bytes(HASH_SIZE).asOpaque();
+const getStateCodec = codec.bytes(HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const stateRootCodec = bytes(HASH_SIZE).asOpaque();
+const stateRootCodec = codec.bytes(HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
-    static Codec = Class(ErrorMessage, {
-        message: string,
+    static Codec = codec.Class(ErrorMessage, {
+        message: codec.string,
     });
     static create({ message }) {
         return new ErrorMessage(message);
@@ -12549,7 +12599,7 @@ var MessageType;
  *     error         [255] Error
  * }
  */
-const messageCodec = custom({
+const messageCodec = codec.custom({
     name: "Message",
     sizeHint: { bytes: 1, isExact: false },
 }, (e, msg) => {
@@ -18034,7 +18084,7 @@ class Assign {
         // NOTE: Here we know the core index is valid
         const coreIndex = tryAsCoreIndex(Number(maybeCoreIndex));
         const decoder = Decoder.fromBlob(res);
-        const authQueue = decoder.sequenceFixLen(bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE);
+        const authQueue = decoder.sequenceFixLen(codec.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE);
         const fixedSizeAuthQueue = FixedSizeArray.new(authQueue, AUTHORIZATION_QUEUE_SIZE);
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
@@ -18058,9 +18108,9 @@ class Assign {
 }
 
 const IN_OUT_REG$m = 7;
-const serviceIdAndGasCodec = object({
-    serviceId: u32.convert((i) => i, (o) => asOpaqueType(o)),
-    gas: u64.convert((i) => tryAsU64(i), (o) => tryAsServiceGas(o)),
+const serviceIdAndGasCodec = codec.object({
+    serviceId: codec.u32.convert((i) => i, (o) => asOpaqueType(o)),
+    gas: codec.u64.convert((i) => tryAsU64(i), (o) => tryAsServiceGas(o)),
 });
 /**
  * Modify privileged services and services that auto-accumulate every block.
@@ -18118,7 +18168,7 @@ class Bless {
             memIndex = tryAsU64(memIndex + tryAsU64(decoder.bytesRead()));
         }
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/367200367200?v=0.6.7
-        const res = safeAllocUint8Array(tryAsExactBytes(u32.sizeHint) * this.chainSpec.coresCount);
+        const res = safeAllocUint8Array(tryAsExactBytes(codec.u32.sizeHint) * this.chainSpec.coresCount);
         const authorizersDecoder = Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
@@ -18126,7 +18176,7 @@ class Bless {
             return PvmExecution.Panic;
         }
         // `a`
-        const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
+        const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
             logger$7.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
@@ -18736,12 +18786,12 @@ class PendingTransfer {
     amount;
     memo;
     gas;
-    static Codec = Class(PendingTransfer, {
-        source: u32.asOpaque(),
-        destination: u32.asOpaque(),
-        amount: u64,
-        memo: bytes(TRANSFER_MEMO_BYTES),
-        gas: u64.asOpaque(),
+    static Codec = codec.Class(PendingTransfer, {
+        source: codec.u32.asOpaque(),
+        destination: codec.u32.asOpaque(),
+        amount: codec.u64,
+        memo: codec.bytes(TRANSFER_MEMO_BYTES),
+        gas: codec.u64.asOpaque(),
     });
     constructor(
     /** `s`: sending service */
@@ -19039,18 +19089,18 @@ class Info {
  *
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
  */
-const codecServiceAccountInfoWithThresholdBalance = object({
-    codeHash: bytes(HASH_SIZE),
-    balance: u64,
-    thresholdBalance: u64,
-    accumulateMinGas: u64.convert((i) => i, tryAsServiceGas),
-    onTransferMinGas: u64.convert((i) => i, tryAsServiceGas),
-    storageUtilisationBytes: u64,
-    storageUtilisationCount: u32,
-    gratisStorage: u64,
-    created: u32.convert((x) => x, tryAsTimeSlot),
-    lastAccumulation: u32.convert((x) => x, tryAsTimeSlot),
-    parentService: u32.convert((x) => x, tryAsServiceId),
+const codecServiceAccountInfoWithThresholdBalance = codec.object({
+    codeHash: codec.bytes(HASH_SIZE),
+    balance: codec.u64,
+    thresholdBalance: codec.u64,
+    accumulateMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    storageUtilisationCount: codec.u32,
+    gratisStorage: codec.u64,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
 }, "ServiceAccountInfoWithThresholdBalance");
 
 const decoder = new TextDecoder("utf8");
@@ -19426,9 +19476,9 @@ class HistoricalLookup {
 
 const IN_OUT_REG_1 = 7;
 const IN_OUT_REG_2 = 8;
-const gasAndRegistersCodec = object({
-    gas: i64,
-    registers: bytes(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE),
+const gasAndRegistersCodec = codec.object({
+    gas: codec.i64,
+    registers: codec.bytes(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE),
 });
 const GAS_REGISTERS_SIZE = tryAsExactBytes(gasAndRegistersCodec.sizeHint);
 /**
@@ -20274,21 +20324,21 @@ const GAS_TO_INVOKE_WORK_REPORT = 10000000n;
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/176b00176b00?v=0.7.2
  */
 class Operand extends WithDebug {
-    static Codec = Class(Operand, {
+    static Codec = codec.Class(Operand, {
         // h
-        hash: bytes(HASH_SIZE).asOpaque(),
+        hash: codec.bytes(HASH_SIZE).asOpaque(),
         // e
-        exportsRoot: bytes(HASH_SIZE).asOpaque(),
+        exportsRoot: codec.bytes(HASH_SIZE).asOpaque(),
         // a
-        authorizerHash: bytes(HASH_SIZE).asOpaque(),
+        authorizerHash: codec.bytes(HASH_SIZE).asOpaque(),
         // y
-        payloadHash: bytes(HASH_SIZE),
+        payloadHash: codec.bytes(HASH_SIZE),
         // g
-        gas: varU64.asOpaque(),
+        gas: codec.varU64.asOpaque(),
         // d
         result: WorkExecResult.Codec,
         // o
-        authorizationOutput: blob,
+        authorizationOutput: codec.blob,
     });
     /**
      * https://graypaper.fluffylabs.dev/#/ab2cdbd/18680118eb01?v=0.7.2
@@ -20471,80 +20521,153 @@ function signingPayload$1(blake2b, anchor, blob) {
     return BytesBlob.blobFromParts(JAM_AVAILABLE, blake2b.hashBytes(BytesBlob.blobFromParts(anchor.raw, blob.raw)).raw);
 }
 
+/** Error that may happen during reports processing. */
+var ReportsError;
+(function (ReportsError) {
+    /** Core index is greater than the number of available cores. */
+    ReportsError[ReportsError["BadCoreIndex"] = 0] = "BadCoreIndex";
+    /** The report slot is greater than the current block slot. */
+    ReportsError[ReportsError["FutureReportSlot"] = 1] = "FutureReportSlot";
+    /** Report is too old to be considered. */
+    ReportsError[ReportsError["ReportEpochBeforeLast"] = 2] = "ReportEpochBeforeLast";
+    /** Not enough credentials for the guarantee. */
+    ReportsError[ReportsError["InsufficientGuarantees"] = 3] = "InsufficientGuarantees";
+    /** Guarantees are not ordered by the core index. */
+    ReportsError[ReportsError["OutOfOrderGuarantee"] = 4] = "OutOfOrderGuarantee";
+    /** Credentials of guarantors are not sorted or unique. */
+    ReportsError[ReportsError["NotSortedOrUniqueGuarantors"] = 5] = "NotSortedOrUniqueGuarantors";
+    /** Validator in credentials is assigned to a different core. */
+    ReportsError[ReportsError["WrongAssignment"] = 6] = "WrongAssignment";
+    /** There is a report pending availability on that core already. */
+    ReportsError[ReportsError["CoreEngaged"] = 7] = "CoreEngaged";
+    /** Anchor block is not found in recent blocks. */
+    ReportsError[ReportsError["AnchorNotRecent"] = 8] = "AnchorNotRecent";
+    /** Service not foubd. */
+    ReportsError[ReportsError["BadServiceId"] = 9] = "BadServiceId";
+    /** Service code hash does not match the current one. */
+    ReportsError[ReportsError["BadCodeHash"] = 10] = "BadCodeHash";
+    /** Pre-requisite work package is missing in either recent blocks or lookup extrinsic. */
+    ReportsError[ReportsError["DependencyMissing"] = 11] = "DependencyMissing";
+    /** Results for the same package are in more than one report. */
+    ReportsError[ReportsError["DuplicatePackage"] = 12] = "DuplicatePackage";
+    /** Anchor block declared state root does not match the one we have in recent blocks. */
+    ReportsError[ReportsError["BadStateRoot"] = 13] = "BadStateRoot";
+    /** BEEFY super hash mmr mismatch. */
+    ReportsError[ReportsError["BadBeefyMmrRoot"] = 14] = "BadBeefyMmrRoot";
+    /** The authorization hash is not found in the authorization pool. */
+    ReportsError[ReportsError["CoreUnauthorized"] = 15] = "CoreUnauthorized";
+    /** Validator index is greater than the number of validators. */
+    ReportsError[ReportsError["BadValidatorIndex"] = 16] = "BadValidatorIndex";
+    /** Total gas of work report is too high. */
+    ReportsError[ReportsError["WorkReportGasTooHigh"] = 17] = "WorkReportGasTooHigh";
+    /** Work item has is smaller than required minimal accumulation gas of a service. */
+    ReportsError[ReportsError["ServiceItemGasTooLow"] = 18] = "ServiceItemGasTooLow";
+    /** The report has too many dependencies (prerequisites and/or segment-root lookups). */
+    ReportsError[ReportsError["TooManyDependencies"] = 19] = "TooManyDependencies";
+    /** Segment root lookup block has invalid time slot or is not found in the header chain. */
+    ReportsError[ReportsError["SegmentRootLookupInvalid"] = 20] = "SegmentRootLookupInvalid";
+    /** Signature in credentials is invalid. */
+    ReportsError[ReportsError["BadSignature"] = 21] = "BadSignature";
+    /** Size of authorizer output and all work-item successful output blobs is too big. */
+    ReportsError[ReportsError["WorkReportTooBig"] = 22] = "WorkReportTooBig";
+    /** Contains guarantee from validator that is proven to be an offender. */
+    ReportsError[ReportsError["BannedValidator"] = 23] = "BannedValidator";
+})(ReportsError || (ReportsError = {}));
+
+/**
+ * `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
+ */
+const MAX_WORK_REPORT_SIZE_BYTES = 48 * 2 ** 10;
+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$1.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$1.error(ReportsError.WorkReportTooBig, () => `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
+        }
+    }
+    return Result$1.ok(OK);
+}
+
 var TransferOperandKind;
 (function (TransferOperandKind) {
     TransferOperandKind[TransferOperandKind["OPERAND"] = 0] = "OPERAND";
     TransferOperandKind[TransferOperandKind["TRANSFER"] = 1] = "TRANSFER";
 })(TransferOperandKind || (TransferOperandKind = {}));
-const TRANSFER_OR_OPERAND = custom({
-    name: "TransferOrOperand",
-    sizeHint: { bytes: 1, isExact: false },
-}, (e, x) => {
-    e.varU32(tryAsU32(x.kind));
-    if (x.kind === TransferOperandKind.OPERAND) {
-        e.object(Operand.Codec, x.value);
-    }
-    if (x.kind === TransferOperandKind.TRANSFER) {
-        e.object(PendingTransfer.Codec, x.value);
-    }
-}, (d) => {
-    const kind = d.varU32();
-    if (kind === TransferOperandKind.OPERAND) {
-        return {
-            kind: TransferOperandKind.OPERAND,
-            value: d.object(Operand.Codec),
-        };
-    }
-    if (kind === TransferOperandKind.TRANSFER) {
-        return { kind: TransferOperandKind.TRANSFER, value: d.object(PendingTransfer.Codec) };
-    }
-    throw new Error(`Unable to decode TransferOrOperand. Invalid kind: ${kind}.`);
-}, (s) => {
-    const kind = s.decoder.varU32();
-    if (kind === TransferOperandKind.OPERAND) {
-        s.object(Operand.Codec);
-    }
-    if (kind === TransferOperandKind.TRANSFER) {
-        s.object(PendingTransfer.Codec);
-    }
+const TRANSFER_OR_OPERAND = codec.union("TransferOrOperand", {
+    [TransferOperandKind.OPERAND]: codec.object({ value: Operand.Codec }),
+    [TransferOperandKind.TRANSFER]: codec.object({ value: PendingTransfer.Codec }),
 });
-const TRANSFERS_AND_OPERANDS = sequenceVarLen(TRANSFER_OR_OPERAND);
+const TRANSFERS_AND_OPERANDS = codec.sequenceVarLen(TRANSFER_OR_OPERAND);
 // https://github.com/gavofyork/graypaper/pull/414
 // 0.7.0 encoding is used for prior versions as well.
-const CONSTANTS_CODEC = object({
-    B_I: u64,
-    B_L: u64,
-    B_S: u64,
-    C: u16,
-    D: u32,
-    E: u32,
-    G_A: u64,
-    G_I: u64,
-    G_R: u64,
-    G_T: u64,
-    H: u16,
-    I: u16,
-    J: u16,
-    K: u16,
-    L: u32,
-    N: u16,
-    O: u16,
-    P: u16,
-    Q: u16,
-    R: u16,
-    T: u16,
-    U: u16,
-    V: u16,
-    W_A: u32,
-    W_B: u32,
-    W_C: u32,
-    W_E: u32,
-    W_M: u32,
-    W_P: u32,
-    W_R: u32,
-    W_T: u32,
-    W_X: u32,
-    Y: u32,
+const CONSTANTS_CODEC = codec.object({
+    B_I: codec.u64,
+    B_L: codec.u64,
+    B_S: codec.u64,
+    C: codec.u16,
+    D: codec.u32,
+    E: codec.u32,
+    G_A: codec.u64,
+    G_I: codec.u64,
+    G_R: codec.u64,
+    G_T: codec.u64,
+    H: codec.u16,
+    I: codec.u16,
+    J: codec.u16,
+    K: codec.u16,
+    L: codec.u32,
+    N: codec.u16,
+    O: codec.u16,
+    P: codec.u16,
+    Q: codec.u16,
+    R: codec.u16,
+    T: codec.u16,
+    U: codec.u16,
+    V: codec.u16,
+    W_A: codec.u32,
+    W_B: codec.u32,
+    W_C: codec.u32,
+    W_E: codec.u32,
+    W_M: codec.u32,
+    W_P: codec.u32,
+    W_R: codec.u32,
+    W_T: codec.u32,
+    W_X: codec.u32,
+    Y: codec.u32,
 });
 const encodedConstantsCache = new Map();
 function getEncodedConstants(chainSpec) {
@@ -20582,7 +20705,7 @@ function getEncodedConstants(chainSpec) {
         W_E: tryAsU32(chainSpec.erasureCodedPieceSize),
         W_M: tryAsU32(W_M),
         W_P: tryAsU32(chainSpec.numberECPiecesPerSegment),
-        W_R: tryAsU32(W_R),
+        W_R: tryAsU32(MAX_WORK_REPORT_SIZE_BYTES),
         W_T: tryAsU32(W_T),
         W_X: tryAsU32(W_X),
         Y: tryAsU32(chainSpec.contestLength),
@@ -20657,7 +20780,7 @@ class FetchExternalities {
     allOperands() {
         if (this.fetchData.context === FetchContext.LegacyAccumulate) {
             const operands = this.fetchData.operands;
-            return Encoder.encodeObject(sequenceVarLen(Operand.Codec), operands, this.chainSpec);
+            return Encoder.encodeObject(codec.sequenceVarLen(Operand.Codec), operands, this.chainSpec);
         }
         return null;
     }
@@ -20678,7 +20801,7 @@ class FetchExternalities {
     allTransfers() {
         if (this.fetchData.context === FetchContext.LegacyOnTransfer) {
             const { transfers } = this.fetchData;
-            return Encoder.encodeObject(sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
+            return Encoder.encodeObject(codec.sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
         }
         return null;
     }
@@ -20909,10 +21032,10 @@ function getWorkPackageHashes(reports) {
     const workPackageHashes = reports.map((report) => report.workPackageSpec.hash);
     return HashSet.from(workPackageHashes);
 }
-const NEXT_ID_CODEC = object({
-    serviceId: varU32.asOpaque(),
-    entropy: bytes(HASH_SIZE).asOpaque(),
-    timeslot: varU32.asOpaque(),
+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.
@@ -21310,21 +21433,24 @@ var PvmInvocationError;
     PvmInvocationError[PvmInvocationError["PreimageTooLong"] = 2] = "PreimageTooLong";
 })(PvmInvocationError || (PvmInvocationError = {}));
 const logger$5 = Logger.new(import.meta.filename, "accumulate");
-const ARGS_CODEC$1 = object({
-    slot: varU32.asOpaque(),
-    serviceId: varU32.asOpaque(),
-    argsLength: varU32,
+const ARGS_CODEC$1 = codec.object({
+    slot: codec.varU32.asOpaque(),
+    serviceId: codec.varU32.asOpaque(),
+    argsLength: codec.varU32,
 });
 class Accumulate {
     chainSpec;
     blake2b;
     state;
-    pvm;
-    constructor(chainSpec, blake2b, state, pvm) {
+    options;
+    constructor(chainSpec, blake2b, state, options) {
         this.chainSpec = chainSpec;
         this.blake2b = blake2b;
         this.state = state;
-        this.pvm = pvm;
+        this.options = options;
+        if (options.accumulateSequentially === true) {
+            logger$5.warn `⚠️ Parallel accumulation is disabled. Running in sequential mode.`;
+        }
     }
     /**
      * Returns an index that determines how many WorkReports can be processed before exceeding a given gasLimit.
@@ -21376,7 +21502,7 @@ class Accumulate {
             serviceExternalities: partialState,
             fetchExternalities,
         };
-        const executor = await PvmExecutor.createAccumulateExecutor(serviceId, code, externalities, this.chainSpec, this.pvm);
+        const executor = await PvmExecutor.createAccumulateExecutor(serviceId, code, externalities, this.chainSpec, this.options.pvm);
         const invocationArgs = Encoder.encodeObject(ARGS_CODEC$1, {
             slot,
             serviceId,
@@ -21593,6 +21719,9 @@ class Accumulate {
                 ];
                 return resultEntry;
             });
+            if (this.options.accumulateSequentially === true) {
+                await promise;
+            }
             resultPromises[serviceIndex] = promise;
         }
         return Promise.all(resultPromises).then((results) => new Map(results));
@@ -21717,10 +21846,10 @@ class Accumulate {
     }
 }
 
-const ARGS_CODEC = object({
-    timeslot: varU32.asOpaque(),
-    serviceId: varU32.asOpaque(),
-    transfersLength: varU32,
+const ARGS_CODEC = codec.object({
+    timeslot: codec.varU32.asOpaque(),
+    serviceId: codec.varU32.asOpaque(),
+    transfersLength: codec.varU32,
 });
 var DeferredTransfersErrorCode;
 (function (DeferredTransfersErrorCode) {
@@ -21901,7 +22030,7 @@ class BlockVerifier {
             }
         }
         // Check if extrinsic is valid.
-        // https://graypaper.fluffylabs.dev/#/cc517d7/0cba000cba00?v=0.6.5
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/0cba000cba00?v=0.7.2
         const extrinsicHash = headerView.extrinsicHash.materialize();
         const extrinsicMerkleCommitment = this.hasher.extrinsic(block.extrinsic.view());
         if (!extrinsicHash.isEqualTo(extrinsicMerkleCommitment.hash)) {
@@ -23227,59 +23356,6 @@ class RecentHistory {
     }
 }
 
-/** Error that may happen during reports processing. */
-var ReportsError;
-(function (ReportsError) {
-    /** Core index is greater than the number of available cores. */
-    ReportsError[ReportsError["BadCoreIndex"] = 0] = "BadCoreIndex";
-    /** The report slot is greater than the current block slot. */
-    ReportsError[ReportsError["FutureReportSlot"] = 1] = "FutureReportSlot";
-    /** Report is too old to be considered. */
-    ReportsError[ReportsError["ReportEpochBeforeLast"] = 2] = "ReportEpochBeforeLast";
-    /** Not enough credentials for the guarantee. */
-    ReportsError[ReportsError["InsufficientGuarantees"] = 3] = "InsufficientGuarantees";
-    /** Guarantees are not ordered by the core index. */
-    ReportsError[ReportsError["OutOfOrderGuarantee"] = 4] = "OutOfOrderGuarantee";
-    /** Credentials of guarantors are not sorted or unique. */
-    ReportsError[ReportsError["NotSortedOrUniqueGuarantors"] = 5] = "NotSortedOrUniqueGuarantors";
-    /** Validator in credentials is assigned to a different core. */
-    ReportsError[ReportsError["WrongAssignment"] = 6] = "WrongAssignment";
-    /** There is a report pending availability on that core already. */
-    ReportsError[ReportsError["CoreEngaged"] = 7] = "CoreEngaged";
-    /** Anchor block is not found in recent blocks. */
-    ReportsError[ReportsError["AnchorNotRecent"] = 8] = "AnchorNotRecent";
-    /** Service not foubd. */
-    ReportsError[ReportsError["BadServiceId"] = 9] = "BadServiceId";
-    /** Service code hash does not match the current one. */
-    ReportsError[ReportsError["BadCodeHash"] = 10] = "BadCodeHash";
-    /** Pre-requisite work package is missing in either recent blocks or lookup extrinsic. */
-    ReportsError[ReportsError["DependencyMissing"] = 11] = "DependencyMissing";
-    /** Results for the same package are in more than one report. */
-    ReportsError[ReportsError["DuplicatePackage"] = 12] = "DuplicatePackage";
-    /** Anchor block declared state root does not match the one we have in recent blocks. */
-    ReportsError[ReportsError["BadStateRoot"] = 13] = "BadStateRoot";
-    /** BEEFY super hash mmr mismatch. */
-    ReportsError[ReportsError["BadBeefyMmrRoot"] = 14] = "BadBeefyMmrRoot";
-    /** The authorization hash is not found in the authorization pool. */
-    ReportsError[ReportsError["CoreUnauthorized"] = 15] = "CoreUnauthorized";
-    /** Validator index is greater than the number of validators. */
-    ReportsError[ReportsError["BadValidatorIndex"] = 16] = "BadValidatorIndex";
-    /** Total gas of work report is too high. */
-    ReportsError[ReportsError["WorkReportGasTooHigh"] = 17] = "WorkReportGasTooHigh";
-    /** Work item has is smaller than required minimal accumulation gas of a service. */
-    ReportsError[ReportsError["ServiceItemGasTooLow"] = 18] = "ServiceItemGasTooLow";
-    /** The report has too many dependencies (prerequisites and/or segment-root lookups). */
-    ReportsError[ReportsError["TooManyDependencies"] = 19] = "TooManyDependencies";
-    /** Segment root lookup block has invalid time slot or is not found in the header chain. */
-    ReportsError[ReportsError["SegmentRootLookupInvalid"] = 20] = "SegmentRootLookupInvalid";
-    /** Signature in credentials is invalid. */
-    ReportsError[ReportsError["BadSignature"] = 21] = "BadSignature";
-    /** Size of authorizer output and all work-item successful output blobs is too big. */
-    ReportsError[ReportsError["WorkReportTooBig"] = 22] = "WorkReportTooBig";
-    /** Contains guarantee from validator that is proven to be an offender. */
-    ReportsError[ReportsError["BannedValidator"] = 23] = "BannedValidator";
-})(ReportsError || (ReportsError = {}));
-
 const ENTROPY_BYTES = 32;
 /**
  * Deterministic variant of the Fisher–Yates shuffle function
@@ -23328,17 +23404,17 @@ var index$5 = /*#__PURE__*/Object.freeze({
  * reports for it. This is borne out with V= 1023 validators
  * and C = 341 cores, since V/C = 3. The core index assigned to
  * each of the validators, as well as the validators’ Ed25519
- * keys are denoted by G.
+ * keys are denoted by M.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/147601147e01
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/144c02145402?v=0.7.2
  */
 /**
  * Returns core assignments for each validator index.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/14fd0114fd01
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/155300155d00?v=0.7.2
  */
 function generateCoreAssignment(spec, blake2b, 
-/** https://graypaper.fluffylabs.dev/#/5f542d7/149601149601 */
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/147102147102?v=0.7.2 */
 eta2entropy, 
 /** timeslot */
 slot) {
@@ -23348,7 +23424,7 @@ slot) {
 function rotationIndex(slot, rotationPeriod) {
     return asOpaqueType(Math.floor(slot / rotationPeriod));
 }
-/** https://graypaper.fluffylabs.dev/#/5f542d7/14c00114c001 */
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/151900151900?v=0.7.2 */
 function permute(blake2b, entropy, slot, spec) {
     const shift = rotationIndex(tryAsTimeSlot(slot % spec.epochLength), spec.rotationPeriod);
     const initialAssignment = Array(spec.validatorsCount)
@@ -23363,58 +23439,14 @@ function permute(blake2b, entropy, slot, spec) {
     // we are sure this is PerValidator, since that's the array we create earlier.
     return asKnownSize(coreAssignment);
 }
-/** https://graypaper.fluffylabs.dev/#/5f542d7/14a50114a501 */
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/148002148002?v=0.7.2 */
 function rotate(cores, n, noOfCores) {
     // modulo `noOfCores` guarantees that we're within `CoreIndex` range.
     return cores.map((x) => asOpaqueType((x + n) % noOfCores));
 }
 
-/**
- * `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
- */
-const MAX_WORK_REPORT_SIZE_BYTES = 48 * 2 ** 10;
-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/#/5f542d7/13ab0013ad00?v=0.6.2
-         */
-        const noOfPrerequisites = reportView.context.view().prerequisites.view().length;
-        const noOfSegmentRootLookups = reportView.segmentRootLookup.view().length;
-        if (noOfPrerequisites + noOfSegmentRootLookups > MAX_REPORT_DEPENDENCIES) {
-            return Result$1.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/#/5f542d7/141d00142000?v=0.6.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()) {
-            totalOutputsSize += item.view().result.view().okBlob?.raw.length ?? 0;
-        }
-        if (authOutputSize + totalOutputsSize > MAX_WORK_REPORT_SIZE_BYTES) {
-            return Result$1.error(ReportsError.WorkReportTooBig, () => `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
-        }
-    }
-    return Result$1.ok(OK);
-}
-
 const logger$3 = Logger.new(import.meta.filename, "stf:reports");
-/** https://graypaper.fluffylabs.dev/#/7e6ff6a/15eb0115eb01?v=0.6.7 */
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/158202158202?v=0.7.2 */
 function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge) {
     const contexts = [];
     // hashes of work packages reported in this extrinsic
@@ -23436,8 +23468,11 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
             if (service === null) {
                 return Result$1.error(ReportsError.BadServiceId, () => `No service with id: ${result.serviceId}`);
             }
-            // check service code hash
-            // https://graypaper.fluffylabs.dev/#/5f542d7/154b02154b02
+            /**
+             * Check service code hash
+             *
+             * https://graypaper.fluffylabs.dev/#/ab2cdbd/150804150804?v=0.7.2
+             */
             if (!result.codeHash.isEqualTo(service.getInfo().codeHash)) {
                 return Result$1.error(ReportsError.BadCodeHash, () => `Service (${result.serviceId}) code hash mismatch. Got: ${result.codeHash}, expected: ${service.getInfo().codeHash}`);
             }
@@ -23447,7 +23482,7 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
      * There must be no duplicate work-package hashes (i.e.
      * two work-reports of the same package).
      *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/151f01152101
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/159c02159e02?v=0.7.2
      */
     if (currentWorkPackages.size !== input.guarantees.length) {
         return Result$1.error(ReportsError.DuplicatePackage, () => "Duplicate work package detected.");
@@ -23501,7 +23536,7 @@ function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge)
     }
     return Result$1.ok(currentWorkPackages);
 }
-/** https://graypaper.fluffylabs.dev/#/7e6ff6a/152502152502?v=0.6.7 */
+/** https://graypaper.fluffylabs.dev/#/ab2cdbd/15cd0215cd02?v=0.7.2 */
 function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate, headerChain) {
     // TODO [ToDr] [opti] This could be cached and updated efficiently between runs.
     const recentBlocks = HashDictionary.new();
@@ -23512,9 +23547,9 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
         /**
          * We require that the anchor block be within the last H
          * blocks and that its details be correct by ensuring that it
-         * appears within our most recent blocks β †:
+         * appears within our most recent blocks β†:
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/152801152b01
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/15ad0215af02?v=0.7.2
          */
         const recentBlock = recentBlocks.get(context.anchor);
         if (recentBlock === undefined) {
@@ -23533,7 +23568,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
          * We require that each lookup-anchor block be within the
          * last L timeslots.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/154601154701
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/15ce0215cf02?v=0.7.2
          */
         if (context.lookupAnchorSlot < minLookupSlot) {
             return Result$1.error(ReportsError.SegmentRootLookupInvalid, () => `Lookup anchor slot's too old. Got: ${context.lookupAnchorSlot}, minimal: ${minLookupSlot}`);
@@ -23544,7 +23579,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
          * on-chain state and must be checked by virtue of retaini
          * ing the series of the last L headers as the ancestor set A.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/155c01155f01
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/15e40215e702?v=0.7.2
          */
         const isInChain = recentBlocks.has(context.lookupAnchor) ||
             headerChain.isAncestor(context.lookupAnchorSlot, context.lookupAnchor, context.anchor);
@@ -23567,7 +23602,7 @@ function verifyDependencies({ currentWorkPackages, recentlyReported, prerequisit
          * segment-root lookup, be either in the extrinsic or in our
          * recent history.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/15ca0115cd01
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/156b03156e03?v=0.7.2
          */
         for (const preReqHash of dependencies) {
             if (currentWorkPackages.has(preReqHash)) {
@@ -23596,7 +23631,7 @@ function verifyWorkPackagesUniqueness(workPackageHashes, state) {
     /**
      * Make sure that the package does not appear anywhere in the pipeline.
      *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/159101159101
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/152803152803?v=0.7.2
      */
     // TODO [ToDr] [opti] this most likely should be cached and either
     // re-computed on invalidity or we could maintain additional
@@ -23637,9 +23672,9 @@ function verifyCredentials(guarantees,
 workReportHashes, slot, getGuarantorAssignment) {
     /**
      * Collect signatures payload for later verification
-     * and construct the `reporters set R` from that data.
+     * and construct the `reporters set G` from that data.
      *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/15cf0015cf00
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/153002153002?v=0.7.2
      */
     const signaturesToVerify = [];
     const headerTimeSlot = slot;
@@ -23653,7 +23688,7 @@ workReportHashes, slot, getGuarantorAssignment) {
          * The credential is a sequence of two or three tuples of a
          * unique validator index and a signature.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/14b90214bb02
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/152b01152d01?v=0.7.2
          */
         const credentialsView = guaranteeView.credentials.view();
         if (credentialsView.length < REQUIRED_CREDENTIALS_RANGE[0] ||
@@ -23683,7 +23718,8 @@ workReportHashes, slot, getGuarantorAssignment) {
             }
             /**
              * Verify core assignment.
-             * https://graypaper.fluffylabs.dev/#/5f542d7/14e40214e602
+             *
+             * https://graypaper.fluffylabs.dev/#/ab2cdbd/155201155401?v=0.7.2
              */
             if (guarantorData.core !== coreIndex) {
                 return Result$1.error(ReportsError.WrongAssignment, () => `Invalid core assignment for validator ${validatorIndex}. Expected: ${guarantorData.core}, got: ${coreIndex}`);
@@ -23702,7 +23738,7 @@ const JAM_GUARANTEE = BytesBlob.blobFromString("jam_guarantee").raw;
  * The signature [...] whose message is the serialization of the hash
  * of the work-report.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/155200155200
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/15a20115a201?v=0.7.2
  */
 function signingPayload(hash) {
     return BytesBlob.blobFromParts(JAM_GUARANTEE, hash.raw);
@@ -23713,7 +23749,7 @@ function verifyReportsOrder(input, chainSpec) {
      * The core index of each guarantee must be unique and
      * guarantees must be in ascending order of this.
      *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/146902146a02
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/15d60015d700?v=0.7.2
      */
     const noOfCores = chainSpec.coresCount;
     let lastCoreIndex = -1;
@@ -23742,7 +23778,7 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
          * No reports may be placed on cores with a report pending
          * availability on it.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/15ea0015ea00
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/155002155002?v=0.7.2
          */
         if (availabilityAssignment[coreIndex] !== null) {
             return Result$1.error(ReportsError.CoreEngaged, () => `Report pending availability at core: ${coreIndex}`);
@@ -23752,7 +23788,7 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
          * in the authorizer pool of the core on which the work is
          * reported.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/15eb0015ed00
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/155102155302?v=0.7.2
          */
         const authorizerHash = report.authorizerHash;
         const authorizerPool = authPools.get(coreIndex);
@@ -23762,10 +23798,10 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
         }
         /**
          * We require that the gas allotted for accumulation of each
-         * work item in each work-report respects its service’s
+         * work-digest in each work-report respects its service’s
          * minimum gas requirements.
          *
-         * https://graypaper.fluffylabs.dev/#/5f542d7/15f80015fa00
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/156602156802?v=0.7.2
          */
         for (const result of report.results) {
             const service = services(result.serviceId);
@@ -23837,10 +23873,11 @@ class Reports {
         /**
          * ρ′ - 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
+         * 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/#/1c979cb/161e00165900?v=0.7.1
+         *
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/161e00165900?v=0.7.2
          */
         const availabilityAssignment = input.assurancesAvailAssignment.slice();
         for (const guarantee of input.guarantees) {
@@ -23870,7 +23907,7 @@ class Reports {
         return asKnownSize(workReportHashes);
     }
     verifyCredentials(input, workReportHashes) {
-        return verifyCredentials(input.guarantees, workReportHashes, input.slot, (headerTimeSlot, guaranteeTimeSlot) => this.getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, input.newEntropy));
+        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();
@@ -23898,15 +23935,15 @@ class Reports {
      * Get the guarantor assignment (both core and validator data)
      * depending on the rotation.
      *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/158200158200
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/15df0115df01?v=0.7.2
      */
-    getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, newEntropy) {
+    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/#/5f542d7/155e00156900
+        // https://graypaper.fluffylabs.dev/#/ab2cdbd/15980115be01?v=0.7.2
         if (guaranteeTimeSlot > headerTimeSlot) {
             return Result$1.error(ReportsError.FutureReportSlot, () => `Report slot is in future. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
         }
@@ -23914,10 +23951,10 @@ class Reports {
             return Result$1.error(ReportsError.ReportEpochBeforeLast, () => `Report slot is too old. Block ${headerTimeSlot}, Report: ${guaranteeTimeSlot}`);
         }
         // TODO [ToDr] [opti] below code needs cache.
-        // The `G` and `G*` sets should only be computed once per rotation.
+        // The `M` and `M*` sets should only be computed once per rotation.
         // Default data for the current rotation
         let entropy = newEntropy[2];
-        let validatorData = this.state.currentValidatorData;
+        let validatorData = currentValidatorData;
         let timeSlot = headerTimeSlot;
         // we might need a different set of data
         if (headerRotation > guaranteeRotation) {
@@ -23927,11 +23964,11 @@ class Reports {
             // if the epoch changed, we need to take previous entropy and previous validator data.
             if (isPreviousRotationPreviousEpoch(timeSlot, headerTimeSlot, epochLength)) {
                 entropy = newEntropy[3];
-                validatorData = this.state.previousValidatorData;
+                validatorData = previousValidatorData;
             }
         }
         // we know which entropy, timeSlot and validatorData should be used,
-        // so we can compute `G` or `G*` here.
+        // so we can compute `M` or `M*` here.
         const coreAssignment = generateCoreAssignment(this.chainSpec, this.blake2b, entropy, timeSlot);
         return Result$1.ok(zip(coreAssignment, validatorData, (core, validator) => ({
             core,
@@ -24099,22 +24136,23 @@ class Statistics {
         const newPreImagesSize = current[authorIndex].preImagesSize + preImagesSize;
         current[authorIndex].preImagesSize = tryAsU32(newPreImagesSize);
         /**
-         * * NOTE [MaSi] Please note I don't use Kappa' here. If I understand correctly we don't need it.
-         * Kappa' is not needed because we can use validator indexes directly from guarantees extrinsic.
-         * I asked a question to ensure it is true but I didn't get any response yet:
-         * https://github.com/w3f/jamtestvectors/pull/28#discussion_r190723700
+         * Update guarantees
          *
-         * https://graypaper.fluffylabs.dev/#/1c979cb/19a00119a801?v=0.7.1
+         * https://graypaper.fluffylabs.dev/#/ab2cdbd/19ea0119f201?v=0.7.2
          */
-        const incrementedGuarantors = new Set();
-        for (const guarantee of extrinsic.guarantees) {
-            for (const { validatorIndex } of guarantee.credentials) {
-                if (!incrementedGuarantors.has(validatorIndex)) {
-                    const newGuaranteesCount = current[validatorIndex].guarantees + 1;
-                    current[validatorIndex].guarantees = tryAsU32(newGuaranteesCount);
-                    incrementedGuarantors.add(validatorIndex);
-                }
+        const validatorKeys = input.currentValidatorData.map((v) => v.ed25519);
+        for (const reporter of input.reporters) {
+            const index = validatorKeys.findIndex((x) => x.isEqualTo(reporter));
+            if (index === -1) {
+                /**
+                 * it should never happen because:
+                 * 1. the extrinsic is verified in reports transition
+                 * 2. we use current validators set from safrole
+                 */
+                continue;
             }
+            const newGuaranteesCount = current[index].guarantees + 1;
+            current[index].guarantees = tryAsU32(newGuaranteesCount);
         }
         for (const { validatorIndex } of extrinsic.assurances) {
             const newAssurancesCount = current[validatorIndex].assurances + 1;
@@ -24269,7 +24307,7 @@ class OnChain {
     // chapter 13: https://graypaper.fluffylabs.dev/#/68eaa1f/18b60118b601?v=0.6.4
     statistics;
     isReadyForNextEpoch = Promise.resolve(false);
-    constructor(chainSpec, state, hasher, pvm, headerChain) {
+    constructor(chainSpec, state, hasher, options, headerChain) {
         this.chainSpec = chainSpec;
         this.state = state;
         this.hasher = hasher;
@@ -24281,9 +24319,9 @@ class OnChain {
         this.disputes = new Disputes(chainSpec, hasher.blake2b, state);
         this.reports = new Reports(chainSpec, hasher.blake2b, state, headerChain);
         this.assurances = new Assurances(chainSpec, state, hasher.blake2b);
-        this.accumulate = new Accumulate(chainSpec, hasher.blake2b, state, pvm);
+        this.accumulate = new Accumulate(chainSpec, hasher.blake2b, state, options);
         this.accumulateOutput = new AccumulateOutput();
-        this.deferredTransfers = new DeferredTransfers(chainSpec, hasher.blake2b, state, pvm);
+        this.deferredTransfers = new DeferredTransfers(chainSpec, hasher.blake2b, state, options.pvm);
         this.preimages = new Preimages(state, hasher.blake2b);
         this.authorization = new Authorization(chainSpec, state);
     }
@@ -24367,12 +24405,13 @@ class OnChain {
             recentBlocksPartialUpdate,
             assurancesAvailAssignment,
             offenders: offendersMark,
+            currentValidatorData,
+            previousValidatorData,
         });
         if (reportsResult.isError) {
             return stfError(StfErrorKind.Reports, reportsResult);
         }
-        // NOTE `reporters` are unused
-        const { reported: workPackages, reporters: _, stateUpdate: reportsUpdate, ...reportsRest } = reportsResult.ok;
+        const { reported: workPackages, reporters, stateUpdate: reportsUpdate, ...reportsRest } = reportsResult.ok;
         assertEmpty(reportsRest);
         const { availabilityAssignment: reportsAvailAssignment, ...reportsUpdateRest } = reportsUpdate;
         assertEmpty(reportsUpdateRest);
@@ -24386,7 +24425,7 @@ class OnChain {
         }
         const { preimages, ...preimagesRest } = preimagesResult.ok;
         assertEmpty(preimagesRest);
-        const timerAccumulate = measure(`import:accumulate (${PvmBackend[this.accumulate.pvm]})`);
+        const timerAccumulate = measure(`import:accumulate (${PvmBackend[this.accumulate.options.pvm]})`);
         // accumulate
         const accumulateResult = await this.accumulate.transition({
             slot: timeSlot,
@@ -24446,6 +24485,8 @@ class OnChain {
             availableReports,
             accumulationStatistics,
             transferStatistics,
+            reporters: reporters,
+            currentValidatorData,
         });
         const { statistics, ...statisticsRest } = statisticsUpdate;
         assertEmpty(statisticsRest);
@@ -24537,7 +24578,7 @@ class TransitionHasher {
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
         const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
-        const countEncoded = Encoder.encodeObject(varU32, guaranteesCount);
+        const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
         const guaranteesBlobs = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
@@ -25378,7 +25419,7 @@ var MetricsAPI = /** @class */ (function () {
 var metrics = MetricsAPI.getInstance();
 
 var name = "@typeberry/importer";
-var version = "0.5.0";
+var version = "0.5.1";
 var packageJson = {
 	name: name,
 	version: version};
@@ -25488,7 +25529,7 @@ class Importer {
             throw new Error(`Unable to load best state from header hash: ${currentBestHeaderHash}.`);
         }
         this.verifier = new BlockVerifier(hasher, blocks);
-        this.stf = new OnChain(spec, state, hasher, pvm, DbHeaderChain.new(blocks));
+        this.stf = new OnChain(spec, state, hasher, { pvm, accumulateSequentially: false }, DbHeaderChain.new(blocks));
         this.state = state;
         this.currentHash = currentBestHeaderHash;
         this.prepareForNextEpoch();
@@ -25634,11 +25675,11 @@ const blake2b = Blake2b.createHasher();
 async function createImporter(config) {
     const chainSpec = config.chainSpec;
     const db = config.openDatabase({ readonly: false });
-    const interpreter = config.workerParams.pvm;
+    const pvm = config.workerParams.pvm;
     const blocks = db.getBlocksDb();
     const states = db.getStatesDb();
     const hasher = new TransitionHasher(await keccakHasher, await blake2b);
-    const importer = new Importer(chainSpec, interpreter, hasher, logger$1, blocks, states);
+    const importer = new Importer(chainSpec, pvm, hasher, logger$1, blocks, states);
     return {
         importer,
         db,
@@ -25807,7 +25848,7 @@ class DirectWorkerConfig {
     workerParams;
     blocksDb;
     statesDb;
-    static new({ nodeName, chainSpec, blocksDb, statesDb, params, }) {
+    static new({ nodeName, chainSpec, blocksDb, statesDb, workerParams: params, }) {
         return new DirectWorkerConfig(nodeName, chainSpec, params, blocksDb, statesDb);
     }
     constructor(nodeName, chainSpec, workerParams, blocksDb, statesDb) {
@@ -26251,7 +26292,7 @@ var index$3 = /*#__PURE__*/Object.freeze({
   startSameThread: startSameThread
 });
 
-const importBlockResultCodec = (hashName) => custom({
+const importBlockResultCodec = (hashName) => codec.custom({
     name: `Result<${hashName}, string>`,
     sizeHint: { bytes: 1, isExact: false },
 }, (e, x) => {
@@ -26289,33 +26330,33 @@ const importBlockResultCodec = (hashName) => custom({
 const protocol = createProtocol("importer", {
     toWorker: {
         getStateEntries: {
-            request: bytes(HASH_SIZE).asOpaque(),
-            response: optional(StateEntries.Codec),
+            request: codec.bytes(HASH_SIZE).asOpaque(),
+            response: codec.optional(StateEntries.Codec),
         },
         getBestStateRootHash: {
-            request: nothing,
-            response: bytes(HASH_SIZE).asOpaque(),
+            request: codec.nothing,
+            response: codec.bytes(HASH_SIZE).asOpaque(),
         },
         importBlock: {
             request: Block.Codec.View,
             response: importBlockResultCodec("HeaderHash"),
         },
         finish: {
-            request: nothing,
-            response: nothing,
+            request: codec.nothing,
+            response: codec.nothing,
         },
     },
     fromWorker: {
         bestHeaderAnnouncement: {
             request: headerViewWithHashCodec,
-            response: nothing,
+            response: codec.nothing,
         },
     },
 });
 class ImporterConfig {
     pvm;
-    static Codec = Class(ImporterConfig, {
-        pvm: u8.convert((i) => tryAsU8(i), (o) => {
+    static Codec = codec.Class(ImporterConfig, {
+        pvm: codec.u8.convert((i) => tryAsU8(i), (o) => {
             if (o === PvmBackend.BuiltIn) {
                 return PvmBackend.BuiltIn;
             }
@@ -26333,7 +26374,7 @@ class ImporterConfig {
     }
 }
 
-const WORKER = new URL(import.meta.resolve("./bootstrap-importer.mjs"));
+const WORKER = new URL("./bootstrap-importer.mjs", import.meta.url);
 
 var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -26780,11 +26821,11 @@ class TestState {
         state_root: fromJson.bytes32(),
         keyvals: json.array(StateKeyVal.fromJson),
     };
-    static Codec = object({
-        state_root: bytes(HASH_SIZE).asOpaque(),
-        keyvals: sequenceVarLen(object({
-            key: bytes(TRUNCATED_HASH_SIZE),
-            value: blob,
+    static Codec = codec.object({
+        state_root: codec.bytes(HASH_SIZE).asOpaque(),
+        keyvals: codec.sequenceVarLen(codec.object({
+            key: codec.bytes(TRUNCATED_HASH_SIZE),
+            value: codec.blob,
         })),
     });
     state_root;
@@ -26795,7 +26836,7 @@ class StateTransitionGenesis {
         header: headerFromJson,
         state: TestState.fromJson,
     };
-    static Codec = object({
+    static Codec = codec.object({
         header: Header.Codec,
         state: TestState.Codec,
     });
@@ -26808,7 +26849,7 @@ class StateTransition {
         post_state: TestState.fromJson,
         block: blockFromJson(tinyChainSpec),
     };
-    static Codec = object({
+    static Codec = codec.object({
         pre_state: TestState.Codec,
         block: Block.Codec,
         post_state: TestState.Codec,