@typeberry/jam 0.2.0-b6e3410 → 0.2.0-c3df163

package/bootstrap-network.mjs

@@ -26103,6 +26103,9 @@ class ObjectView {
     toString() {
         return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
     }
+    [TEST_COMPARE_USING]() {
+        return this.materialize();
+    }
 }
 /**
  * A lazy-evaluated decoder of a sequence.
@@ -26235,7 +26238,7 @@ const TYPICAL_DICTIONARY_LENGTH = 32;
  *       It's not true in a general case, but should be good enough for us.
  *
  */
-function readonlyArray(desc) {
+function descriptors_readonlyArray(desc) {
     return desc.convert((x) => {
         debug_check `
         ${Array.isArray(x)}
@@ -26397,7 +26400,15 @@ var descriptors_codec;
     /** Custom encoding / decoding logic. */
     codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
     /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), chooser(null).View);
+    codec.select = ({ name, sizeHint, }, chooser) => {
+        const Self = chooser(null);
+        return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
+            ? codec.select({
+                name: Self.View.name,
+                sizeHint: Self.View.sizeHint,
+            }, (ctx) => chooser(ctx).View)
+            : Self.View);
+    };
     /**
      * A descriptor for a more complex POJO.
      *
@@ -27219,7 +27230,7 @@ const BANDERSNATCH_KEY_BYTES = 32;
 /** Bandersnatch VRF signature size */
 const bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES = 96;
 /** Bandersnatch ring commitment size */
-const BANDERSNATCH_RING_ROOT_BYTES = 144;
+const bandersnatch_BANDERSNATCH_RING_ROOT_BYTES = 144;
 /** Bandersnatch proof size */
 const BANDERSNATCH_PROOF_BYTES = 784;
 /** BLS public key size. */
@@ -28800,9 +28811,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return readonlyArray(descriptors_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
+        return descriptors_readonlyArray(descriptors_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
     }
-    return readonlyArray(descriptors_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
+    return descriptors_readonlyArray(descriptors_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -29176,16 +29187,16 @@ class SignedTicket extends WithDebug {
     }
 }
 /** Anonymous? entry into the ticket contest. */
-class Ticket extends WithDebug {
+class tickets_Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = descriptors_codec.Class(Ticket, {
+    static Codec = descriptors_codec.Class(tickets_Ticket, {
         id: descriptors_codec.bytes(hash_HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
         attempt: descriptors_codec.u8.asOpaque(),
     });
     static create({ id, attempt }) {
-        return new Ticket(id, attempt);
+        return new tickets_Ticket(id, attempt);
     }
     constructor(
     /**
@@ -29297,7 +29308,7 @@ function tryAsPerValidator(array, spec) {
   `;
     return sized_array_asKnownSize(array);
 }
-const codecPerValidator = (val) => codecWithContext((context) => {
+const common_codecPerValidator = (val) => codecWithContext((context) => {
     return codecKnownSizeArray(val, {
         fixedLength: context.validatorsCount,
     });
@@ -29424,7 +29435,7 @@ class Verdict extends WithDebug {
         workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
         votesEpoch: descriptors_codec.u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return readonlyArray(descriptors_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority)).convert(seeThrough, sized_array_asKnownSize);
+            return descriptors_readonlyArray(descriptors_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority)).convert(seeThrough, sized_array_asKnownSize);
         }),
     });
     static create({ workReportHash, votesEpoch, votes }) {
@@ -30116,7 +30127,7 @@ const WorkReportCodec = descriptors_codec.Class(WorkReportNoCodec, {
     authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
     authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
     authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
+    segmentRootLookup: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
     results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
 });
 const WorkReportCodecPre070 = descriptors_codec.Class(WorkReportNoCodec, {
@@ -30130,7 +30141,7 @@ const WorkReportCodecPre070 = descriptors_codec.Class(WorkReportNoCodec, {
     }),
     authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
     authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
+    segmentRootLookup: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
     results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
 });
@@ -30251,7 +30262,7 @@ class ValidatorKeys extends WithDebug {
 class TicketsMarker extends WithDebug {
     tickets;
     static Codec = descriptors_codec.Class(TicketsMarker, {
-        tickets: codecPerEpochBlock(Ticket.Codec),
+        tickets: codecPerEpochBlock(tickets_Ticket.Codec),
     });
     static create({ tickets }) {
         return new TicketsMarker(tickets);
@@ -30275,7 +30286,7 @@ class EpochMarker extends WithDebug {
     static Codec = descriptors_codec.Class(EpochMarker, {
         entropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
         ticketsEntropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        validators: codecPerValidator(ValidatorKeys.Codec),
+        validators: common_codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
         return new EpochMarker(entropy, ticketsEntropy, validators);
@@ -30547,6 +30558,19 @@ function emptyBlock(slot = tryAsTimeSlot(0)) {
     });
 }
 
+;// CONCATENATED MODULE: ./packages/jam/block/utils.ts
+
+/**
+ * Take an input data and re-encode that data as view.
+ *
+ * NOTE: this function should NEVER be used in any production code,
+ * it's only a test helper.
+ */
+function reencodeAsView(codec, object, chainSpec) {
+    const encoded = encoder_Encoder.encodeObject(codec, object, chainSpec);
+    return decoder_Decoder.decodeObject(codec.View, encoded, chainSpec);
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/block/index.ts
 
 
@@ -30565,6 +30589,7 @@ function emptyBlock(slot = tryAsTimeSlot(0)) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/block-json/disputes-extrinsic.ts
 
 
@@ -30804,7 +30829,7 @@ const epochMark = descriptors_json.object({
 const ticket = descriptors_json.object({
     id: common_fromJson.bytes32(),
     attempt: common_fromJson.ticketAttempt,
-}, (x) => Ticket.create({ id: x.id, attempt: x.attempt }));
+}, (x) => tickets_Ticket.create({ id: x.id, attempt: x.attempt }));
 const header_headerFromJson = descriptors_json.object({
     parent: common_fromJson.bytes32(),
     parent_state_root: common_fromJson.bytes32(),
@@ -31728,10 +31753,129 @@ function accumulationOutputComparator(a, b) {
     return Ordering.Equal;
 }
 
+;// CONCATENATED MODULE: ./packages/jam/block/gp-constants.ts
+
+
+/**
+ * This file lists all of the constants defined in the GrayPaper appendix.
+ *
+ * NOTE: Avoid using the constants directly, prefer "named" constants defined
+ * in a semantical proximity to where they are used.
+ *
+ * NOTE: This file will most likely be removed in the future. The constants
+ * here are only temporarily for convenience. When we figure out better names
+ * and places for these this file will be eradicated.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/442300442300?v=0.7.2
+ */
+/** `G_I`: The gas allocated to invoke a work-package’s Is-Authorized logic. */
+const G_I = 50_000_000;
+/** `I`: Maximum number of work items in a package. */
+const gp_constants_I = (/* unused pure expression or super */ null && (MAX_NUMBER_OF_WORK_ITEMS));
+/** `O`: Maximum number of items in the authorizations pool. */
+const O = 8;
+/** `Q`: The number of items in the authorizations queue. */
+const Q = 80;
+/** `S`: The maximum number of entries in the accumulation queue. */
+const S = 1024;
+/** `T`: The maximum number of extrinsics in a work-package. */
+const T = 128;
+/** `W_A`: The maximum size of is-authorized code in octets. */
+const W_A = 64_000;
+/** `W_B`: The maximum size of the concatenated variable-size blobs, extrinsics and imported segments of a work-package, in octets */
+const W_B = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2) ? 13_791_360 : 13_794_305;
+/** `W_C`: The maximum size of service code in octets. */
+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. */
+const W_X = 3_072;
+// TODO [ToDr] Not sure where these should live yet :(
+/**
+ * `S`: The minimum public service index.
+ * Services of indices below these may only be created by the Registrar.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/447a00447a00?v=0.7.2
+ */
+const MIN_PUBLIC_SERVICE_INDEX = (/* unused pure expression or super */ null && (2 ** 16));
+/**
+ * `J`: The maximum sum of dependency items in a work-report.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
+ */
+const MAX_REPORT_DEPENDENCIES = 8;
+
+;// CONCATENATED MODULE: ./packages/jam/state/accumulation-queue.ts
+
+
+
+
+
+
+
+/**
+ * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
+ */
+class NotYetAccumulatedReport extends WithDebug {
+    report;
+    dependencies;
+    static Codec = descriptors_codec.Class(NotYetAccumulatedReport, {
+        report: WorkReport.Codec,
+        dependencies: codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+            typicalLength: MAX_REPORT_DEPENDENCIES / 2,
+            maxLength: MAX_REPORT_DEPENDENCIES,
+            minLength: 0,
+        }),
+    });
+    static create({ report, dependencies }) {
+        return new NotYetAccumulatedReport(report, dependencies);
+    }
+    constructor(
+    /**
+     * Each of these were made available at most one epoch ago
+     * but have or had unfulfilled dependencies.
+     */
+    report, 
+    /**
+     * Alongside the work-report itself, we retain its un-accumulated
+     * dependencies, a set of work-package hashes.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
+     */
+    dependencies) {
+        super();
+        this.report = report;
+        this.dependencies = dependencies;
+    }
+}
+const accumulationQueueCodec = codecPerEpochBlock(descriptors_readonlyArray(descriptors_codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
+
+;// CONCATENATED MODULE: ./packages/jam/state/common.ts
+
+
+/** Check if given array has correct length before casting to the opaque type. */
+function tryAsPerCore(array, spec) {
+    debug_check `
+    ${array.length === spec.coresCount}
+    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
+  `;
+    return opaque_asOpaqueType(array);
+}
+const codecPerCore = (val) => codecWithContext((context) => {
+    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
+});
+
 ;// CONCATENATED MODULE: ./packages/jam/state/assurances.ts
 
 
 
+
 /**
  * Assignment of particular work report to a core.
  *
@@ -31760,27 +31904,30 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
+const availabilityAssignmentsCodec = codecPerCore(descriptors_codec.optional(AvailabilityAssignment.Codec));
 
-;// CONCATENATED MODULE: ./packages/jam/state/common.ts
+;// CONCATENATED MODULE: ./packages/jam/state/auth.ts
 
 
-/** Check if given array has correct length before casting to the opaque type. */
-function tryAsPerCore(array, spec) {
-    debug_check `
-    ${array.length === spec.coresCount}
-    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
-  `;
-    return opaque_asOpaqueType(array);
-}
-const codecPerCore = (val) => codecWithContext((context) => {
-    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
-});
+
+
+
+/** `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(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+    minLength: 0,
+    maxLength: MAX_AUTH_POOL_SIZE,
+    typicalLength: MAX_AUTH_POOL_SIZE,
+}));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/disputes.ts
 
 
 
-const sortedSetCodec = () => readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return sorted_set_SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -31842,65 +31989,6 @@ function hashComparator(a, b) {
     return a.compare(b);
 }
 
-;// CONCATENATED MODULE: ./packages/jam/block/gp-constants.ts
-
-/**
- * This file lists all of the constants defined in the GrayPaper appendix.
- *
- * NOTE: Avoid using the constants directly, prefer "named" constants defined
- * in a semantical proximity to where they are used.
- *
- * NOTE: This file will most likely be removed in the future. The constants
- * here are only temporarily for convenience. When we figure out better names
- * and places for these this file will be eradicated.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/413000413000
- */
-/** `G_I`: The gas allocated to invoke a work-package’s Is-Authorized logic. */
-const G_I = 50_000_000;
-/** `I`: Maximum number of work items in a package. */
-const gp_constants_I = (/* unused pure expression or super */ null && (MAX_NUMBER_OF_WORK_ITEMS));
-/** `O`: Maximum number of items in the authorizations pool. */
-const O = 8;
-/** `Q`: The number of items in the authorizations queue. */
-const Q = 80;
-/** `S`: The maximum number of entries in the accumulation queue. */
-const S = 1024;
-/** `T`: The maximum number of extrinsics in a work-package. */
-const T = 128;
-/** `W_A`: The maximum size of is-authorized code in octets. */
-const W_A = 64_000;
-/** `W_B`: The maximum size of an encoded work-package with extrinsic data and imports. */
-const W_B = 13_794_305;
-/** `W_C`: The maximum size of service code in octets. */
-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. */
-const W_X = 3_072;
-// TODO [ToDr] Not sure where these should live yet :(
-/**
- * `S`: The minimum public service index.
- * Services of indices below these may only be created by the Registrar.
- *
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/447a00447a00?v=0.7.2
- */
-const MIN_PUBLIC_SERVICE_INDEX = (/* unused pure expression or super */ null && (2 ** 16));
-/**
- * `J`: The maximum sum of dependency items in a work-report.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
- */
-const MAX_REPORT_DEPENDENCIES = 8;
-/** `Q`: Size of the authorization queue. */
-const AUTHORIZATION_QUEUE_SIZE = Q;
-/** `O`: Maximal authorization pool size. */
-const MAX_AUTH_POOL_SIZE = O;
-
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
 const MAX_VALUE = 4294967295;
 const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
@@ -31908,7 +31996,7 @@ const MIN_VALUE = (/* unused pure expression or super */ null && (-(2 ** 31)));
 const MAX_SHIFT_U32 = 32;
 const MAX_SHIFT_U64 = 64n;
 
-;// CONCATENATED MODULE: ./packages/jam/state/service.ts
+;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
 
 
 
@@ -31916,28 +32004,272 @@ const MAX_SHIFT_U64 = 64n;
 
 
 /**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-const BASE_SERVICE_BALANCE = 100n;
-/**
- * `B_I`: The additional minimum balance required per item of elective service state.
+ * `H = 8`: The size of recent history, in blocks.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
  */
-const ELECTIVE_ITEM_BALANCE = 10n;
+const MAX_RECENT_HISTORY = 8;
+/** Recent history of a single block. */
+class BlockState extends WithDebug {
+    headerHash;
+    accumulationResult;
+    postStateRoot;
+    reported;
+    static Codec = descriptors_codec.Class(BlockState, {
+        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        accumulationResult: descriptors_codec.bytes(hash_HASH_SIZE),
+        postStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
+    });
+    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
+        return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
+    }
+    constructor(
+    /** Header hash. */
+    headerHash, 
+    /** Merkle mountain belt of accumulation result. */
+    accumulationResult, 
+    /** Posterior state root filled in with a 1-block delay. */
+    postStateRoot, 
+    /** Reported work packages (no more than number of cores). */
+    reported) {
+        super();
+        this.headerHash = headerHash;
+        this.accumulationResult = accumulationResult;
+        this.postStateRoot = postStateRoot;
+        this.reported = reported;
+    }
+}
 /**
- * `B_L`: The additional minimum balance required per octet of elective service state.
+ * Recent history of blocks.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
  */
-const ELECTIVE_BYTE_BALANCE = 1n;
-const zeroSizeHint = {
-    bytes: 0,
-    isExact: true,
-};
-/** 0-byte read, return given default value */
+class RecentBlocks extends WithDebug {
+    blocks;
+    accumulationLog;
+    static Codec = descriptors_codec.Class(RecentBlocks, {
+        blocks: codecKnownSizeArray(BlockState.Codec, {
+            minLength: 0,
+            maxLength: MAX_RECENT_HISTORY,
+            typicalLength: MAX_RECENT_HISTORY,
+        }),
+        accumulationLog: descriptors_codec.object({
+            peaks: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.optional(descriptors_codec.bytes(hash_HASH_SIZE)))),
+        }),
+    });
+    static empty() {
+        return new RecentBlocks(sized_array_asKnownSize([]), {
+            peaks: [],
+        });
+    }
+    static create(a) {
+        return new RecentBlocks(a.blocks, a.accumulationLog);
+    }
+    constructor(
+    /**
+     * Most recent blocks.
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fea010fea01?v=0.6.7
+     */
+    blocks, 
+    /**
+     * Accumulation output log.
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0f02020f0202?v=0.6.7
+     */
+    accumulationLog) {
+        super();
+        this.blocks = blocks;
+        this.accumulationLog = accumulationLog;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/state/recently-accumulated.ts
+
+
+
+
+const recentlyAccumulatedCodec = codecPerEpochBlock(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+
+;// CONCATENATED MODULE: ./packages/jam/state/validator-data.ts
+
+
+
+
+/**
+ * Fixed size of validator metadata.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
+ */
+const VALIDATOR_META_BYTES = 128;
+/**
+ * Details about validators' identity.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
+ */
+class validator_data_ValidatorData extends WithDebug {
+    bandersnatch;
+    ed25519;
+    bls;
+    metadata;
+    static Codec = descriptors_codec.Class(validator_data_ValidatorData, {
+        bandersnatch: descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+        bls: descriptors_codec.bytes(BLS_KEY_BYTES).asOpaque(),
+        metadata: descriptors_codec.bytes(VALIDATOR_META_BYTES),
+    });
+    static create({ ed25519, bandersnatch, bls, metadata }) {
+        return new validator_data_ValidatorData(bandersnatch, ed25519, bls, metadata);
+    }
+    constructor(
+    /** Bandersnatch public key. */
+    bandersnatch, 
+    /** ED25519 key data. */
+    ed25519, 
+    /** BLS public key. */
+    bls, 
+    /** Validator-defined additional metdata. */
+    metadata) {
+        super();
+        this.bandersnatch = bandersnatch;
+        this.ed25519 = ed25519;
+        this.bls = bls;
+        this.metadata = metadata;
+    }
+}
+const validatorsDataCodec = common_codecPerValidator(validator_data_ValidatorData.Codec);
+
+;// CONCATENATED MODULE: ./packages/jam/state/safrole-data.ts
+
+
+
+
+
+
+
+
+
+
+
+var SafroleSealingKeysKind;
+(function (SafroleSealingKeysKind) {
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
+})(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
+const codecBandersnatchKey = descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+class safrole_data_SafroleSealingKeysData extends WithDebug {
+    kind;
+    keys;
+    tickets;
+    static Codec = codecWithContext((context) => {
+        return descriptors_codec.custom({
+            name: "SafroleSealingKeys",
+            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
+        }, (e, x) => {
+            e.varU32(numbers_tryAsU32(x.kind));
+            if (x.kind === SafroleSealingKeysKind.Keys) {
+                e.sequenceFixLen(codecBandersnatchKey, x.keys);
+            }
+            else {
+                e.sequenceFixLen(tickets_Ticket.Codec, x.tickets);
+            }
+        }, (d) => {
+            const epochLength = context.epochLength;
+            const kind = d.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
+                return safrole_data_SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                const tickets = d.sequenceFixLen(tickets_Ticket.Codec, epochLength);
+                return safrole_data_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(tickets_Ticket.Codec, context.epochLength);
+                return;
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        });
+    });
+    static keys(keys) {
+        return new safrole_data_SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
+    }
+    static tickets(tickets) {
+        return new safrole_data_SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
+    }
+    constructor(kind, keys, tickets) {
+        super();
+        this.kind = kind;
+        this.keys = keys;
+        this.tickets = tickets;
+    }
+}
+class safrole_data_SafroleData {
+    nextValidatorData;
+    epochRoot;
+    sealingKeySeries;
+    ticketsAccumulator;
+    static Codec = descriptors_codec.Class(safrole_data_SafroleData, {
+        nextValidatorData: common_codecPerValidator(validator_data_ValidatorData.Codec),
+        epochRoot: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        sealingKeySeries: safrole_data_SafroleSealingKeysData.Codec,
+        ticketsAccumulator: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(tickets_Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+    });
+    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
+        return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
+    }
+    constructor(
+    /** gamma_k */
+    nextValidatorData, 
+    /** gamma_z */
+    epochRoot, 
+    /** gamma_s */
+    sealingKeySeries, 
+    /** gamma_a */
+    ticketsAccumulator) {
+        this.nextValidatorData = nextValidatorData;
+        this.epochRoot = epochRoot;
+        this.sealingKeySeries = sealingKeySeries;
+        this.ticketsAccumulator = ticketsAccumulator;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/state/service.ts
+
+
+
+
+
+
+/**
+ * `B_S`: The basic minimum balance which all services require.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
+ */
+const BASE_SERVICE_BALANCE = 100n;
+/**
+ * `B_I`: The additional minimum balance required per item of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
+ */
+const ELECTIVE_ITEM_BALANCE = 10n;
+/**
+ * `B_L`: The additional minimum balance required per octet of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ */
+const ELECTIVE_BYTE_BALANCE = 1n;
+const zeroSizeHint = {
+    bytes: 0,
+    isExact: true,
+};
+/** 0-byte read, return given default value */
 const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
 /** Encode and decode object with leading version number. */
 const codecWithVersion = (val) => Descriptor.new("withVersion", {
@@ -32098,358 +32430,418 @@ class LookupHistoryItem {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
+;// CONCATENATED MODULE: ./packages/jam/state/statistics.ts
 
 
 
 
 
-/** Dictionary entry of services that auto-accumulate every block. */
-class AutoAccumulate {
-    service;
-    gasLimit;
-    static Codec = descriptors_codec.Class(AutoAccumulate, {
-        service: descriptors_codec.u32.asOpaque(),
-        gasLimit: descriptors_codec.u64.asOpaque(),
+
+const codecServiceId = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
+    ? descriptors_codec.u32.asOpaque()
+    : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => tryAsServiceId(i));
+/**
+ * Activity Record of a single validator.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
+ */
+class ValidatorStatistics {
+    blocks;
+    tickets;
+    preImages;
+    preImagesSize;
+    guarantees;
+    assurances;
+    static Codec = descriptors_codec.Class(ValidatorStatistics, {
+        blocks: descriptors_codec.u32,
+        tickets: descriptors_codec.u32,
+        preImages: descriptors_codec.u32,
+        preImagesSize: descriptors_codec.u32,
+        guarantees: descriptors_codec.u32,
+        assurances: descriptors_codec.u32,
     });
-    static create({ service, gasLimit }) {
-        return new AutoAccumulate(service, gasLimit);
+    static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
+        return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
     }
     constructor(
-    /** Service id that auto-accumulates. */
-    service, 
-    /** Gas limit for auto-accumulation. */
-    gasLimit) {
-        this.service = service;
-        this.gasLimit = gasLimit;
-    }
-}
-/**
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
- */
-class PrivilegedServices {
-    manager;
-    delegator;
-    registrar;
-    assigners;
-    autoAccumulateServices;
-    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = descriptors_codec.Class(PrivilegedServices, {
-        manager: descriptors_codec.u32.asOpaque(),
-        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
-        delegator: descriptors_codec.u32.asOpaque(),
-        registrar: compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1)
-            ? descriptors_codec.u32.asOpaque()
-            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: readonlyArray(descriptors_codec.sequenceVarLen(AutoAccumulate.Codec)),
-    });
-    static create(a) {
-        return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+    /** The number of blocks produced by the validator. */
+    blocks, 
+    /** The number of tickets introduced by the validator. */
+    tickets, 
+    /** The number of preimages introduced by the validator. */
+    preImages, 
+    /** The total number of octets across all preimages introduced by the validator. */
+    preImagesSize, 
+    /** The number of reports guaranteed by the validator. */
+    guarantees, 
+    /** The number of availability assurances made by the validator. */
+    assurances) {
+        this.blocks = blocks;
+        this.tickets = tickets;
+        this.preImages = preImages;
+        this.preImagesSize = preImagesSize;
+        this.guarantees = guarantees;
+        this.assurances = assurances;
     }
-    constructor(
-    /**
-     * `χ_M`: Manages alteration of χ from block to block,
-     * as well as bestow services with storage deposit credits.
-     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
-     */
-    manager, 
-    /** `χ_V`: Managers validator keys. */
-    delegator, 
-    /**
-     * `χ_R`: Manages the creation of services in protected range.
-     *
-     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
-     */
-    registrar, 
-    /** `χ_A`: Manages authorization queue one for each core. */
-    assigners, 
-    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    autoAccumulateServices) {
-        this.manager = manager;
-        this.delegator = delegator;
-        this.registrar = registrar;
-        this.assigners = assigners;
-        this.autoAccumulateServices = autoAccumulateServices;
+    static empty() {
+        const zero = numbers_tryAsU32(0);
+        return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-
-;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
-
-
-
-
-
-
+const codecVarU16 = descriptors_codec.varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
+/** Encode/decode unsigned gas. */
+const codecVarGas = descriptors_codec.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
- * `H = 8`: The size of recent history, in blocks.
+ * Single core statistics.
+ * Updated per block, based on incoming work reports (`w`).
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
+ * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
  */
-const MAX_RECENT_HISTORY = 8;
-/** Recent history of a single block. */
-class BlockState extends WithDebug {
-    headerHash;
-    accumulationResult;
-    postStateRoot;
-    reported;
-    static Codec = descriptors_codec.Class(BlockState, {
-        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        accumulationResult: descriptors_codec.bytes(hash_HASH_SIZE),
-        postStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
-    });
-    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
-        return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
+class CoreStatistics {
+    dataAvailabilityLoad;
+    popularity;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    bundleSize;
+    gasUsed;
+    static Codec = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_0)
+        ? descriptors_codec.Class(CoreStatistics, {
+            dataAvailabilityLoad: descriptors_codec.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            extrinsicCount: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            exports: codecVarU16,
+            bundleSize: descriptors_codec.varU32,
+            gasUsed: codecVarGas,
+        })
+        : descriptors_codec.Class(CoreStatistics, {
+            dataAvailabilityLoad: descriptors_codec.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            extrinsicCount: codecVarU16,
+            bundleSize: descriptors_codec.varU32,
+            gasUsed: codecVarGas,
+        });
+    static create(v) {
+        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
     }
     constructor(
-    /** Header hash. */
-    headerHash, 
-    /** Merkle mountain belt of accumulation result. */
-    accumulationResult, 
-    /** Posterior state root filled in with a 1-block delay. */
-    postStateRoot, 
-    /** Reported work packages (no more than number of cores). */
-    reported) {
-        super();
-        this.headerHash = headerHash;
-        this.accumulationResult = accumulationResult;
-        this.postStateRoot = postStateRoot;
-        this.reported = reported;
-    }
-}
-class RecentBlocks extends WithDebug {
-    blocks;
-    accumulationLog;
-    static Codec = descriptors_codec.Class(RecentBlocks, {
-        blocks: codecKnownSizeArray(BlockState.Codec, {
-            minLength: 0,
-            maxLength: MAX_RECENT_HISTORY,
-            typicalLength: MAX_RECENT_HISTORY,
-        }),
-        accumulationLog: descriptors_codec.object({
-            peaks: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.optional(descriptors_codec.bytes(hash_HASH_SIZE)))),
-        }),
-    });
-    static create(a) {
-        return new RecentBlocks(a.blocks, a.accumulationLog);
+    /** `d` */
+    dataAvailabilityLoad, 
+    /** `p` */
+    popularity, 
+    /** `i` */
+    imports, 
+    /** `e` */
+    exports, 
+    /** `z` */
+    extrinsicSize, 
+    /** `x` */
+    extrinsicCount, 
+    /** `b` */
+    bundleSize, 
+    /** `u` */
+    gasUsed) {
+        this.dataAvailabilityLoad = dataAvailabilityLoad;
+        this.popularity = popularity;
+        this.imports = imports;
+        this.exports = exports;
+        this.extrinsicSize = extrinsicSize;
+        this.extrinsicCount = extrinsicCount;
+        this.bundleSize = bundleSize;
+        this.gasUsed = gasUsed;
     }
-    constructor(
-    /**
-     * Most recent blocks.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fea010fea01?v=0.6.7
-     */
-    blocks, 
-    /**
-     * Accumulation output log.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0f02020f0202?v=0.6.7
-     */
-    accumulationLog) {
-        super();
-        this.blocks = blocks;
-        this.accumulationLog = accumulationLog;
+    static empty() {
+        const zero = numbers_tryAsU32(0);
+        const zero16 = numbers_tryAsU16(0);
+        const zeroGas = tryAsServiceGas(0);
+        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
     }
 }
 /**
- * Recent history of blocks.
+ * Service statistics.
+ * Updated per block, based on available work reports (`W`).
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
  */
-class RecentBlocksHistory extends WithDebug {
-    current;
-    static Codec = Descriptor.new("RecentBlocksHistory", RecentBlocks.Codec.sizeHint, (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()), (decoder) => {
-        const recentBlocks = RecentBlocks.Codec.decode(decoder);
-        return RecentBlocksHistory.create(recentBlocks);
-    }, (skip) => {
-        return RecentBlocks.Codec.skip(skip);
+class ServiceStatistics {
+    providedCount;
+    providedSize;
+    refinementCount;
+    refinementGasUsed;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    accumulateCount;
+    accumulateGasUsed;
+    onTransfersCount;
+    onTransfersGasUsed;
+    static Codec = compatibility_Compatibility.selectIfGreaterOrEqual({
+        fallback: descriptors_codec.Class(ServiceStatistics, {
+            providedCount: codecVarU16,
+            providedSize: descriptors_codec.varU32,
+            refinementCount: descriptors_codec.varU32,
+            refinementGasUsed: codecVarGas,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            extrinsicCount: codecVarU16,
+            accumulateCount: descriptors_codec.varU32,
+            accumulateGasUsed: codecVarGas,
+            onTransfersCount: descriptors_codec.varU32,
+            onTransfersGasUsed: codecVarGas,
+        }),
+        versions: {
+            [compatibility_GpVersion.V0_7_0]: descriptors_codec.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: descriptors_codec.varU32,
+                refinementCount: descriptors_codec.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: descriptors_codec.varU32,
+                exports: codecVarU16,
+                accumulateCount: descriptors_codec.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: descriptors_codec.varU32,
+                onTransfersGasUsed: codecVarGas,
+            }),
+            [compatibility_GpVersion.V0_7_1]: descriptors_codec.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: descriptors_codec.varU32,
+                refinementCount: descriptors_codec.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: descriptors_codec.varU32,
+                exports: codecVarU16,
+                accumulateCount: descriptors_codec.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
+                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
+            }),
+        },
     });
-    static create(recentBlocks) {
-        return new RecentBlocksHistory(recentBlocks);
+    static create(v) {
+        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
+    }
+    constructor(
+    /** `p.0` */
+    providedCount, 
+    /** `p.1` */
+    providedSize, 
+    /** `r.0` */
+    refinementCount, 
+    /** `r.1` */
+    refinementGasUsed, 
+    /** `i` */
+    imports, 
+    /** `e` */
+    exports, 
+    /** `z` */
+    extrinsicSize, 
+    /** `x` */
+    extrinsicCount, 
+    /** `a.0` */
+    accumulateCount, 
+    /** `a.1` */
+    accumulateGasUsed, 
+    /** `t.0` @deprecated since 0.7.1 */
+    onTransfersCount, 
+    /** `t.1` @deprecated since 0.7.1 */
+    onTransfersGasUsed) {
+        this.providedCount = providedCount;
+        this.providedSize = providedSize;
+        this.refinementCount = refinementCount;
+        this.refinementGasUsed = refinementGasUsed;
+        this.imports = imports;
+        this.exports = exports;
+        this.extrinsicSize = extrinsicSize;
+        this.extrinsicCount = extrinsicCount;
+        this.accumulateCount = accumulateCount;
+        this.accumulateGasUsed = accumulateGasUsed;
+        this.onTransfersCount = onTransfersCount;
+        this.onTransfersGasUsed = onTransfersGasUsed;
     }
     static empty() {
-        return RecentBlocksHistory.create(RecentBlocks.create({
-            blocks: sized_array_asKnownSize([]),
-            accumulationLog: { peaks: [] },
-        }));
+        const zero = numbers_tryAsU32(0);
+        const zero16 = numbers_tryAsU16(0);
+        const zeroGas = tryAsServiceGas(0);
+        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
     }
-    /**
-     * Returns the block's BEEFY super peak.
-     */
-    static accumulationResult(block) {
-        return block.accumulationResult;
+}
+/** `pi`: Statistics of each validator, cores statistics and services statistics. */
+class StatisticsData {
+    current;
+    previous;
+    cores;
+    services;
+    static Codec = descriptors_codec.Class(StatisticsData, {
+        current: common_codecPerValidator(ValidatorStatistics.Codec),
+        previous: common_codecPerValidator(ValidatorStatistics.Codec),
+        cores: codecPerCore(CoreStatistics.Codec),
+        services: descriptors_codec.dictionary(codecServiceId, ServiceStatistics.Codec, {
+            sortKeys: (a, b) => a - b,
+        }),
+    });
+    static create(v) {
+        return new StatisticsData(v.current, v.previous, v.cores, v.services);
     }
-    constructor(current) {
-        super();
+    constructor(current, previous, cores, services) {
         this.current = current;
-    }
-    /** History of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
-    get blocks() {
-        if (this.current !== null) {
-            return this.current.blocks;
-        }
-        throw new Error("RecentBlocksHistory is in invalid state");
-    }
-    asCurrent() {
-        if (this.current === null) {
-            throw new Error("Cannot access current RecentBlocks format");
-        }
-        return this.current;
-    }
-    updateBlocks(blocks) {
-        if (this.current !== null) {
-            return RecentBlocksHistory.create(RecentBlocks.create({
-                ...this.current,
-                blocks: opaque_asOpaqueType(blocks),
-            }));
-        }
-        throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
+        this.previous = previous;
+        this.cores = cores;
+        this.services = services;
     }
 }
 
-;// CONCATENATED MODULE: ./packages/jam/state/validator-data.ts
+;// CONCATENATED MODULE: ./packages/jam/state/in-memory-state-view.ts
 
 
 
-/**
- * Fixed size of validator metadata.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
- */
-const VALIDATOR_META_BYTES = 128;
-/**
- * Details about validators' identity.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
- */
-class ValidatorData extends WithDebug {
-    bandersnatch;
-    ed25519;
-    bls;
-    metadata;
-    static Codec = descriptors_codec.Class(ValidatorData, {
-        bandersnatch: descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: descriptors_codec.bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: descriptors_codec.bytes(VALIDATOR_META_BYTES),
-    });
-    static create({ ed25519, bandersnatch, bls, metadata }) {
-        return new ValidatorData(bandersnatch, ed25519, bls, metadata);
-    }
-    constructor(
-    /** Bandersnatch public key. */
-    bandersnatch, 
-    /** ED25519 key data. */
-    ed25519, 
-    /** BLS public key. */
-    bls, 
-    /** Validator-defined additional metdata. */
-    metadata) {
-        super();
-        this.bandersnatch = bandersnatch;
-        this.ed25519 = ed25519;
-        this.bls = bls;
-        this.metadata = metadata;
-    }
-}
 
-;// CONCATENATED MODULE: ./packages/jam/state/safrole-data.ts
 
 
 
 
 
 
+class InMemoryStateView {
+    chainSpec;
+    state;
+    constructor(chainSpec, state) {
+        this.chainSpec = chainSpec;
+        this.state = state;
+    }
+    availabilityAssignmentView() {
+        return reencodeAsView(availabilityAssignmentsCodec, this.state.availabilityAssignment, this.chainSpec);
+    }
+    designatedValidatorDataView() {
+        return reencodeAsView(validatorsDataCodec, this.state.designatedValidatorData, this.chainSpec);
+    }
+    currentValidatorDataView() {
+        return reencodeAsView(validatorsDataCodec, this.state.currentValidatorData, this.chainSpec);
+    }
+    previousValidatorDataView() {
+        return reencodeAsView(validatorsDataCodec, this.state.previousValidatorData, this.chainSpec);
+    }
+    authPoolsView() {
+        return reencodeAsView(authPoolsCodec, this.state.authPools, this.chainSpec);
+    }
+    authQueuesView() {
+        return reencodeAsView(authQueuesCodec, this.state.authQueues, this.chainSpec);
+    }
+    recentBlocksView() {
+        return reencodeAsView(RecentBlocks.Codec, this.state.recentBlocks, this.chainSpec);
+    }
+    statisticsView() {
+        return reencodeAsView(StatisticsData.Codec, this.state.statistics, this.chainSpec);
+    }
+    accumulationQueueView() {
+        return reencodeAsView(accumulationQueueCodec, this.state.accumulationQueue, this.chainSpec);
+    }
+    recentlyAccumulatedView() {
+        return reencodeAsView(recentlyAccumulatedCodec, this.state.recentlyAccumulated, this.chainSpec);
+    }
+    safroleDataView() {
+        // TODO [ToDr] Consider exposting `safrole` from state
+        // instead of individual fields
+        const safrole = safrole_data_SafroleData.create({
+            nextValidatorData: this.state.nextValidatorData,
+            epochRoot: this.state.epochRoot,
+            sealingKeySeries: this.state.sealingKeySeries,
+            ticketsAccumulator: this.state.ticketsAccumulator,
+        });
+        return reencodeAsView(safrole_data_SafroleData.Codec, safrole, this.chainSpec);
+    }
+    getServiceInfoView(id) {
+        const service = this.state.getService(id);
+        if (service === null) {
+            return null;
+        }
+        return reencodeAsView(ServiceAccountInfo.Codec, service.getInfo(), this.chainSpec);
+    }
+}
 
+;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
 
 
 
 
-var SafroleSealingKeysKind;
-(function (SafroleSealingKeysKind) {
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
-})(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
-class SafroleSealingKeysData extends WithDebug {
-    kind;
-    keys;
-    tickets;
-    static Codec = codecWithContext((context) => {
-        return descriptors_codec.custom({
-            name: "SafroleSealingKeys",
-            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
-        }, (e, x) => {
-            e.varU32(numbers_tryAsU32(x.kind));
-            if (x.kind === SafroleSealingKeysKind.Keys) {
-                e.sequenceFixLen(codecBandersnatchKey, 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}`);
-        });
-    });
-    static keys(keys) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
-    }
-    static tickets(tickets) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
+
+/** Dictionary entry of services that auto-accumulate every block. */
+class AutoAccumulate {
+    service;
+    gasLimit;
+    static Codec = descriptors_codec.Class(AutoAccumulate, {
+        service: descriptors_codec.u32.asOpaque(),
+        gasLimit: descriptors_codec.u64.asOpaque(),
+    });
+    static create({ service, gasLimit }) {
+        return new AutoAccumulate(service, gasLimit);
     }
-    constructor(kind, keys, tickets) {
-        super();
-        this.kind = kind;
-        this.keys = keys;
-        this.tickets = tickets;
+    constructor(
+    /** Service id that auto-accumulates. */
+    service, 
+    /** Gas limit for auto-accumulation. */
+    gasLimit) {
+        this.service = service;
+        this.gasLimit = gasLimit;
     }
 }
-class safrole_data_SafroleData {
-    nextValidatorData;
-    epochRoot;
-    sealingKeySeries;
-    ticketsAccumulator;
-    static Codec = descriptors_codec.Class(safrole_data_SafroleData, {
-        nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
-        sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+/**
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
+ */
+class PrivilegedServices {
+    manager;
+    delegator;
+    registrar;
+    assigners;
+    autoAccumulateServices;
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
+    static Codec = descriptors_codec.Class(PrivilegedServices, {
+        manager: descriptors_codec.u32.asOpaque(),
+        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
+        delegator: descriptors_codec.u32.asOpaque(),
+        registrar: compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1)
+            ? descriptors_codec.u32.asOpaque()
+            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
+        autoAccumulateServices: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(AutoAccumulate.Codec)),
     });
-    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
-        return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
+    static create(a) {
+        return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
     }
     constructor(
-    /** gamma_k */
-    nextValidatorData, 
-    /** gamma_z */
-    epochRoot, 
-    /** gamma_s */
-    sealingKeySeries, 
-    /** gamma_a */
-    ticketsAccumulator) {
-        this.nextValidatorData = nextValidatorData;
-        this.epochRoot = epochRoot;
-        this.sealingKeySeries = sealingKeySeries;
-        this.ticketsAccumulator = ticketsAccumulator;
+    /**
+     * `χ_M`: Manages alteration of χ from block to block,
+     * as well as bestow services with storage deposit credits.
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
+     */
+    manager, 
+    /** `χ_V`: Managers validator keys. */
+    delegator, 
+    /**
+     * `χ_R`: Manages the creation of services in protected range.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
+     */
+    registrar, 
+    /** `χ_A`: Manages authorization queue one for each core. */
+    assigners, 
+    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
+    autoAccumulateServices) {
+        this.manager = manager;
+        this.delegator = delegator;
+        this.registrar = registrar;
+        this.assigners = assigners;
+        this.autoAccumulateServices = autoAccumulateServices;
     }
 }
 
@@ -32567,322 +32959,50 @@ class UpdateService {
         });
     }
     static create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new UpdateService(serviceId, {
-            kind: state_update_UpdateServiceKind.Create,
-            account: serviceInfo,
-            lookupHistory,
-        });
-    }
-}
-/** Update service storage kind. */
-var state_update_UpdateStorageKind;
-(function (UpdateStorageKind) {
-    /** Set a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
-    /** Remove a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
-})(state_update_UpdateStorageKind || (state_update_UpdateStorageKind = {}));
-/**
- * Update service storage item.
- *
- * Can either create/modify an entry or remove it.
- */
-class UpdateStorage {
-    serviceId;
-    action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
-        this.action = action;
-    }
-    static set({ serviceId, storage }) {
-        return new UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Set, storage });
-    }
-    static remove({ serviceId, key }) {
-        return new UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Remove, key });
-    }
-    get key() {
-        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
-            return this.action.key;
-        }
-        return this.action.storage.key;
-    }
-    get value() {
-        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
-            return null;
-        }
-        return this.action.storage.value;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/jam/state/statistics.ts
-
-
-
-
-
-
-const codecServiceId = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
-    ? descriptors_codec.u32.asOpaque()
-    : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => tryAsServiceId(i));
-/**
- * Activity Record of a single validator.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
- */
-class ValidatorStatistics {
-    blocks;
-    tickets;
-    preImages;
-    preImagesSize;
-    guarantees;
-    assurances;
-    static Codec = descriptors_codec.Class(ValidatorStatistics, {
-        blocks: descriptors_codec.u32,
-        tickets: descriptors_codec.u32,
-        preImages: descriptors_codec.u32,
-        preImagesSize: descriptors_codec.u32,
-        guarantees: descriptors_codec.u32,
-        assurances: descriptors_codec.u32,
-    });
-    static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
-        return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
-    }
-    constructor(
-    /** The number of blocks produced by the validator. */
-    blocks, 
-    /** The number of tickets introduced by the validator. */
-    tickets, 
-    /** The number of preimages introduced by the validator. */
-    preImages, 
-    /** The total number of octets across all preimages introduced by the validator. */
-    preImagesSize, 
-    /** The number of reports guaranteed by the validator. */
-    guarantees, 
-    /** The number of availability assurances made by the validator. */
-    assurances) {
-        this.blocks = blocks;
-        this.tickets = tickets;
-        this.preImages = preImages;
-        this.preImagesSize = preImagesSize;
-        this.guarantees = guarantees;
-        this.assurances = assurances;
-    }
-    static empty() {
-        const zero = numbers_tryAsU32(0);
-        return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
-    }
-}
-const codecVarU16 = descriptors_codec.varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
-/** Encode/decode unsigned gas. */
-const codecVarGas = descriptors_codec.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
-/**
- * Single core statistics.
- * Updated per block, based on incoming work reports (`w`).
- *
- * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
- * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
- */
-class CoreStatistics {
-    dataAvailabilityLoad;
-    popularity;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    bundleSize;
-    gasUsed;
-    static Codec = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_0)
-        ? descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            extrinsicCount: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            exports: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
-            gasUsed: codecVarGas,
-        })
-        : descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            extrinsicCount: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
-            gasUsed: codecVarGas,
-        });
-    static create(v) {
-        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
-    }
-    constructor(
-    /** `d` */
-    dataAvailabilityLoad, 
-    /** `p` */
-    popularity, 
-    /** `i` */
-    imports, 
-    /** `e` */
-    exports, 
-    /** `z` */
-    extrinsicSize, 
-    /** `x` */
-    extrinsicCount, 
-    /** `b` */
-    bundleSize, 
-    /** `u` */
-    gasUsed) {
-        this.dataAvailabilityLoad = dataAvailabilityLoad;
-        this.popularity = popularity;
-        this.imports = imports;
-        this.exports = exports;
-        this.extrinsicSize = extrinsicSize;
-        this.extrinsicCount = extrinsicCount;
-        this.bundleSize = bundleSize;
-        this.gasUsed = gasUsed;
-    }
-    static empty() {
-        const zero = numbers_tryAsU32(0);
-        const zero16 = numbers_tryAsU16(0);
-        const zeroGas = tryAsServiceGas(0);
-        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
+        return new UpdateService(serviceId, {
+            kind: state_update_UpdateServiceKind.Create,
+            account: serviceInfo,
+            lookupHistory,
+        });
     }
 }
+/** Update service storage kind. */
+var state_update_UpdateStorageKind;
+(function (UpdateStorageKind) {
+    /** Set a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
+    /** Remove a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
+})(state_update_UpdateStorageKind || (state_update_UpdateStorageKind = {}));
 /**
- * Service statistics.
- * Updated per block, based on available work reports (`W`).
+ * Update service storage item.
  *
- * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
+ * Can either create/modify an entry or remove it.
  */
-class ServiceStatistics {
-    providedCount;
-    providedSize;
-    refinementCount;
-    refinementGasUsed;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    accumulateCount;
-    accumulateGasUsed;
-    onTransfersCount;
-    onTransfersGasUsed;
-    static Codec = compatibility_Compatibility.selectIfGreaterOrEqual({
-        fallback: descriptors_codec.Class(ServiceStatistics, {
-            providedCount: codecVarU16,
-            providedSize: descriptors_codec.varU32,
-            refinementCount: descriptors_codec.varU32,
-            refinementGasUsed: codecVarGas,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            extrinsicCount: codecVarU16,
-            accumulateCount: descriptors_codec.varU32,
-            accumulateGasUsed: codecVarGas,
-            onTransfersCount: descriptors_codec.varU32,
-            onTransfersGasUsed: codecVarGas,
-        }),
-        versions: {
-            [compatibility_GpVersion.V0_7_0]: descriptors_codec.Class(ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: descriptors_codec.varU32,
-                refinementCount: descriptors_codec.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: descriptors_codec.varU32,
-                exports: codecVarU16,
-                accumulateCount: descriptors_codec.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: descriptors_codec.varU32,
-                onTransfersGasUsed: codecVarGas,
-            }),
-            [compatibility_GpVersion.V0_7_1]: descriptors_codec.Class(ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: descriptors_codec.varU32,
-                refinementCount: descriptors_codec.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: descriptors_codec.varU32,
-                exports: codecVarU16,
-                accumulateCount: descriptors_codec.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
-                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
-            }),
-        },
-    });
-    static create(v) {
-        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
+class UpdateStorage {
+    serviceId;
+    action;
+    constructor(serviceId, action) {
+        this.serviceId = serviceId;
+        this.action = action;
     }
-    constructor(
-    /** `p.0` */
-    providedCount, 
-    /** `p.1` */
-    providedSize, 
-    /** `r.0` */
-    refinementCount, 
-    /** `r.1` */
-    refinementGasUsed, 
-    /** `i` */
-    imports, 
-    /** `e` */
-    exports, 
-    /** `z` */
-    extrinsicSize, 
-    /** `x` */
-    extrinsicCount, 
-    /** `a.0` */
-    accumulateCount, 
-    /** `a.1` */
-    accumulateGasUsed, 
-    /** `t.0` @deprecated since 0.7.1 */
-    onTransfersCount, 
-    /** `t.1` @deprecated since 0.7.1 */
-    onTransfersGasUsed) {
-        this.providedCount = providedCount;
-        this.providedSize = providedSize;
-        this.refinementCount = refinementCount;
-        this.refinementGasUsed = refinementGasUsed;
-        this.imports = imports;
-        this.exports = exports;
-        this.extrinsicSize = extrinsicSize;
-        this.extrinsicCount = extrinsicCount;
-        this.accumulateCount = accumulateCount;
-        this.accumulateGasUsed = accumulateGasUsed;
-        this.onTransfersCount = onTransfersCount;
-        this.onTransfersGasUsed = onTransfersGasUsed;
+    static set({ serviceId, storage }) {
+        return new UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Set, storage });
     }
-    static empty() {
-        const zero = numbers_tryAsU32(0);
-        const zero16 = numbers_tryAsU16(0);
-        const zeroGas = tryAsServiceGas(0);
-        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
+    static remove({ serviceId, key }) {
+        return new UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Remove, key });
     }
-}
-/** `pi`: Statistics of each validator, cores statistics and services statistics. */
-class StatisticsData {
-    current;
-    previous;
-    cores;
-    services;
-    static Codec = descriptors_codec.Class(StatisticsData, {
-        current: codecPerValidator(ValidatorStatistics.Codec),
-        previous: codecPerValidator(ValidatorStatistics.Codec),
-        cores: codecPerCore(CoreStatistics.Codec),
-        services: descriptors_codec.dictionary(codecServiceId, ServiceStatistics.Codec, {
-            sortKeys: (a, b) => a - b,
-        }),
-    });
-    static create(v) {
-        return new StatisticsData(v.current, v.previous, v.cores, v.services);
+    get key() {
+        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
+            return this.action.key;
+        }
+        return this.action.storage.key;
     }
-    constructor(current, previous, cores, services) {
-        this.current = current;
-        this.previous = previous;
-        this.cores = cores;
-        this.services = services;
+    get value() {
+        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
+            return null;
+        }
+        return this.action.storage.value;
     }
 }
 
@@ -32907,6 +33027,7 @@ class StatisticsData {
 
 
 
+
 
 
 var in_memory_state_UpdateError;
@@ -33007,10 +33128,11 @@ class InMemoryService extends WithDebug {
 /**
  * A special version of state, stored fully in-memory.
  */
-class InMemoryState extends WithDebug {
+class in_memory_state_InMemoryState extends WithDebug {
+    chainSpec;
     /** Create a new `InMemoryState` by providing all required fields. */
-    static create(state) {
-        return new InMemoryState(state);
+    static new(chainSpec, state) {
+        return new in_memory_state_InMemoryState(chainSpec, state);
     }
     /**
      * Create a new `InMemoryState` with a partial state override.
@@ -33019,14 +33141,14 @@ class InMemoryState extends WithDebug {
      * not-necessarily coherent values.
      */
     static partial(spec, partial) {
-        const state = InMemoryState.empty(spec);
+        const state = in_memory_state_InMemoryState.empty(spec);
         Object.assign(state, partial);
         return state;
     }
     /**
      * Create a new `InMemoryState` from some other state object.
      */
-    static copyFrom(other, servicesData) {
+    static copyFrom(chainSpec, other, servicesData) {
         const services = new Map();
         for (const [id, entries] of servicesData.entries()) {
             const service = other.getService(id);
@@ -33036,7 +33158,7 @@ class InMemoryState extends WithDebug {
             const inMemService = InMemoryService.copyFrom(service, entries);
             services.set(id, inMemService);
         }
-        return InMemoryState.create({
+        return in_memory_state_InMemoryState.new(chainSpec, {
             availabilityAssignment: other.availabilityAssignment,
             accumulationQueue: other.accumulationQueue,
             designatedValidatorData: other.designatedValidatorData,
@@ -33233,8 +33355,9 @@ class InMemoryState extends WithDebug {
     getService(id) {
         return this.services.get(id) ?? null;
     }
-    constructor(s) {
+    constructor(chainSpec, s) {
         super();
+        this.chainSpec = chainSpec;
         this.availabilityAssignment = s.availabilityAssignment;
         this.designatedValidatorData = s.designatedValidatorData;
         this.nextValidatorData = s.nextValidatorData;
@@ -33256,31 +33379,34 @@ class InMemoryState extends WithDebug {
         this.accumulationOutputLog = s.accumulationOutputLog;
         this.services = s.services;
     }
+    view() {
+        return new InMemoryStateView(this.chainSpec, this);
+    }
     /**
      * Create an empty and possibly incoherent `InMemoryState`.
      */
     static empty(spec) {
-        return new InMemoryState({
+        return new in_memory_state_InMemoryState(spec, {
             availabilityAssignment: tryAsPerCore(Array.from({ length: spec.coresCount }, () => null), spec),
-            designatedValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorData.create({
+            designatedValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => validator_data_ValidatorData.create({
                 bandersnatch: bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
                 bls: bytes_Bytes.zero(BLS_KEY_BYTES).asOpaque(),
                 ed25519: bytes_Bytes.zero(ED25519_KEY_BYTES).asOpaque(),
                 metadata: bytes_Bytes.zero(VALIDATOR_META_BYTES).asOpaque(),
             })), spec),
-            nextValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorData.create({
+            nextValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => validator_data_ValidatorData.create({
                 bandersnatch: bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
                 bls: bytes_Bytes.zero(BLS_KEY_BYTES).asOpaque(),
                 ed25519: bytes_Bytes.zero(ED25519_KEY_BYTES).asOpaque(),
                 metadata: bytes_Bytes.zero(VALIDATOR_META_BYTES).asOpaque(),
             })), spec),
-            currentValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorData.create({
+            currentValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => validator_data_ValidatorData.create({
                 bandersnatch: bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
                 bls: bytes_Bytes.zero(BLS_KEY_BYTES).asOpaque(),
                 ed25519: bytes_Bytes.zero(ED25519_KEY_BYTES).asOpaque(),
                 metadata: bytes_Bytes.zero(VALIDATOR_META_BYTES).asOpaque(),
             })), spec),
-            previousValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorData.create({
+            previousValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => validator_data_ValidatorData.create({
                 bandersnatch: bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
                 bls: bytes_Bytes.zero(BLS_KEY_BYTES).asOpaque(),
                 ed25519: bytes_Bytes.zero(ED25519_KEY_BYTES).asOpaque(),
@@ -33296,7 +33422,7 @@ class InMemoryState extends WithDebug {
             entropy: FixedSizeArray.fill(() => bytes_Bytes.zero(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
             authPools: tryAsPerCore(Array.from({ length: spec.coresCount }, () => sized_array_asKnownSize([])), spec),
             authQueues: tryAsPerCore(Array.from({ length: spec.coresCount }, () => FixedSizeArray.fill(() => bytes_Bytes.zero(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE)), spec),
-            recentBlocks: RecentBlocksHistory.empty(),
+            recentBlocks: RecentBlocks.empty(),
             statistics: StatisticsData.create({
                 current: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()), spec),
                 previous: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()), spec),
@@ -33306,8 +33432,8 @@ class InMemoryState extends WithDebug {
             accumulationQueue: tryAsPerEpochBlock(Array.from({ length: spec.epochLength }, () => []), spec),
             recentlyAccumulated: tryAsPerEpochBlock(Array.from({ length: spec.epochLength }, () => HashSet.new()), spec),
             ticketsAccumulator: sized_array_asKnownSize([]),
-            sealingKeySeries: SafroleSealingKeysData.keys(tryAsPerEpochBlock(Array.from({ length: spec.epochLength }, () => bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque()), spec)),
-            epochRoot: bytes_Bytes.zero(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+            sealingKeySeries: safrole_data_SafroleSealingKeysData.keys(tryAsPerEpochBlock(Array.from({ length: spec.epochLength }, () => bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque()), spec)),
+            epochRoot: bytes_Bytes.zero(bandersnatch_BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
             privilegedServices: PrivilegedServices.create({
                 manager: tryAsServiceId(0),
                 assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
@@ -33347,51 +33473,10 @@ const serviceDataCodec = descriptors_codec.dictionary(descriptors_codec.u32.asOp
 
 
 
-;// CONCATENATED MODULE: ./packages/jam/state/not-yet-accumulated.ts
-
-
 
 
 
 
-/**
- * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
- */
-class NotYetAccumulatedReport extends WithDebug {
-    report;
-    dependencies;
-    static Codec = descriptors_codec.Class(NotYetAccumulatedReport, {
-        report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
-            typicalLength: MAX_REPORT_DEPENDENCIES / 2,
-            maxLength: MAX_REPORT_DEPENDENCIES,
-            minLength: 0,
-        }),
-    });
-    static create({ report, dependencies }) {
-        return new NotYetAccumulatedReport(report, dependencies);
-    }
-    constructor(
-    /**
-     * Each of these were made available at most one epoch ago
-     * but have or had unfulfilled dependencies.
-     */
-    report, 
-    /**
-     * Alongside the work-report itself, we retain its un-accumulated
-     * dependencies, a set of work-package hashes.
-     *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
-     */
-    dependencies) {
-        super();
-        this.report = report;
-        this.dependencies = dependencies;
-    }
-}
-
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialize.ts
 
 
@@ -33404,26 +33489,19 @@ class NotYetAccumulatedReport extends WithDebug {
 
 
 
-
-
-
 /** Serialization for particular state entries. */
 var serialize_serialize;
 (function (serialize) {
     /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
     serialize.authPools = {
         key: stateKeys.index(StateKeyIdx.Alpha),
-        Codec: codecPerCore(codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
-            minLength: 0,
-            maxLength: MAX_AUTH_POOL_SIZE,
-            typicalLength: MAX_AUTH_POOL_SIZE,
-        })),
+        Codec: authPoolsCodec,
         extract: (s) => s.authPools,
     };
     /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
     serialize.authQueues = {
         key: stateKeys.index(StateKeyIdx.Phi),
-        Codec: codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE)),
+        Codec: authQueuesCodec,
         extract: (s) => s.authQueues,
     };
     /**
@@ -33432,7 +33510,7 @@ var serialize_serialize;
      */
     serialize.recentBlocks = {
         key: stateKeys.index(StateKeyIdx.Beta),
-        Codec: RecentBlocksHistory.Codec,
+        Codec: RecentBlocks.Codec,
         extract: (s) => s.recentBlocks,
     };
     /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
@@ -33461,25 +33539,25 @@ var serialize_serialize;
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
     serialize.designatedValidators = {
         key: stateKeys.index(StateKeyIdx.Iota),
-        Codec: codecPerValidator(ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.designatedValidatorData,
     };
     /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
     serialize.currentValidators = {
         key: stateKeys.index(StateKeyIdx.Kappa),
-        Codec: codecPerValidator(ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.currentValidatorData,
     };
     /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
     serialize.previousValidators = {
         key: stateKeys.index(StateKeyIdx.Lambda),
-        Codec: codecPerValidator(ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.previousValidatorData,
     };
     /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
     serialize.availabilityAssignment = {
         key: stateKeys.index(StateKeyIdx.Rho),
-        Codec: codecPerCore(descriptors_codec.optional(AvailabilityAssignment.Codec)),
+        Codec: availabilityAssignmentsCodec,
         extract: (s) => s.availabilityAssignment,
     };
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
@@ -33503,13 +33581,13 @@ var serialize_serialize;
     /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
     serialize.accumulationQueue = {
         key: stateKeys.index(StateKeyIdx.Omega),
-        Codec: codecPerEpochBlock(readonlyArray(descriptors_codec.sequenceVarLen(NotYetAccumulatedReport.Codec))),
+        Codec: accumulationQueueCodec,
         extract: (s) => s.accumulationQueue,
     };
     /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
     serialize.recentlyAccumulated = {
         key: stateKeys.index(StateKeyIdx.Xi),
-        Codec: codecPerEpochBlock(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x))),
+        Codec: recentlyAccumulatedCodec,
         extract: (s) => s.recentlyAccumulated,
     };
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
@@ -33538,7 +33616,7 @@ var serialize_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(descriptors_codec.sequenceVarLen(descriptors_codec.u32)),
+        Codec: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32)),
     });
 })(serialize_serialize || (serialize_serialize = {}));
 /**
@@ -33550,6 +33628,87 @@ var serialize_serialize;
  */
 const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
 
+;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state-view.ts
+
+
+class serialized_state_view_SerializedStateView {
+    spec;
+    backend;
+    recentlyUsedServices;
+    viewCache;
+    constructor(spec, backend, 
+    /** Best-effort list of recently active services. */
+    recentlyUsedServices, viewCache) {
+        this.spec = spec;
+        this.backend = backend;
+        this.recentlyUsedServices = recentlyUsedServices;
+        this.viewCache = viewCache;
+    }
+    retrieveView({ key, Codec }, description) {
+        const cached = this.viewCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const bytes = this.backend.get(key);
+        if (bytes === null) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing view of key: ${key}`);
+        }
+        // NOTE [ToDr] we are not using `Decoder.decodeObject` here because
+        // it needs to get to the end of the data (skip), yet that's expensive.
+        // we assume that the state data is correct and coherent anyway, so
+        // for performance reasons we simply create the view here.
+        const d = Decoder.fromBytesBlob(bytes);
+        d.attachContext(this.spec);
+        const view = Codec.View.decode(d);
+        this.viewCache.set(key, view);
+        return view;
+    }
+    availabilityAssignmentView() {
+        return this.retrieveView(serialize.availabilityAssignment, "availabilityAssignmentView");
+    }
+    designatedValidatorDataView() {
+        return this.retrieveView(serialize.designatedValidators, "designatedValidatorsView");
+    }
+    currentValidatorDataView() {
+        return this.retrieveView(serialize.currentValidators, "currentValidatorsView");
+    }
+    previousValidatorDataView() {
+        return this.retrieveView(serialize.previousValidators, "previousValidatorsView");
+    }
+    authPoolsView() {
+        return this.retrieveView(serialize.authPools, "authPoolsView");
+    }
+    authQueuesView() {
+        return this.retrieveView(serialize.authQueues, "authQueuesView");
+    }
+    recentBlocksView() {
+        return this.retrieveView(serialize.recentBlocks, "recentBlocksView");
+    }
+    statisticsView() {
+        return this.retrieveView(serialize.statistics, "statisticsView");
+    }
+    accumulationQueueView() {
+        return this.retrieveView(serialize.accumulationQueue, "accumulationQueueView");
+    }
+    recentlyAccumulatedView() {
+        return this.retrieveView(serialize.recentlyAccumulated, "recentlyAccumulatedView");
+    }
+    safroleDataView() {
+        return this.retrieveView(serialize.safrole, "safroleDataView");
+    }
+    getServiceInfoView(id) {
+        const serviceData = serialize.serviceData(id);
+        const bytes = this.backend.get(serviceData.key);
+        if (bytes === null) {
+            return null;
+        }
+        if (!this.recentlyUsedServices.includes(id)) {
+            this.recentlyUsedServices.push(id);
+        }
+        return Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state.ts
 
 
@@ -33558,6 +33717,8 @@ const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) =
 
 
 
+
+
 /**
  * State object which reads it's entries from some backend.
  *
@@ -33570,7 +33731,7 @@ class serialized_state_SerializedState {
     spec;
     blake2b;
     backend;
-    _recentServiceIds;
+    recentlyUsedServices;
     /** Create a state-like object from collection of serialized entries. */
     static fromStateEntries(spec, blake2b, state, recentServices = []) {
         return new serialized_state_SerializedState(spec, blake2b, state, recentServices);
@@ -33579,49 +33740,63 @@ class serialized_state_SerializedState {
     static new(spec, blake2b, db, recentServices = []) {
         return new serialized_state_SerializedState(spec, blake2b, db, recentServices);
     }
+    dataCache = HashDictionary.new();
+    viewCache = HashDictionary.new();
     constructor(spec, blake2b, backend, 
     /** Best-effort list of recently active services. */
-    _recentServiceIds) {
+    recentlyUsedServices) {
         this.spec = spec;
         this.blake2b = blake2b;
         this.backend = backend;
-        this._recentServiceIds = _recentServiceIds;
+        this.recentlyUsedServices = recentlyUsedServices;
     }
     /** Comparing the serialized states, just means comparing their backends. */
     [TEST_COMPARE_USING]() {
         return this.backend;
     }
+    /** Return a non-decoding version of the state. */
+    view() {
+        return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
+    }
     // TODO [ToDr] Temporary method to update the state,
     // without changing references.
     updateBackend(newBackend) {
         this.backend = newBackend;
+        this.dataCache = HashDictionary.new();
+        this.viewCache = HashDictionary.new();
     }
     recentServiceIds() {
-        return this._recentServiceIds;
+        return this.recentlyUsedServices;
     }
     getService(id) {
         const serviceData = this.retrieveOptional(serialize.serviceData(id));
         if (serviceData === undefined) {
             return null;
         }
-        if (!this._recentServiceIds.includes(id)) {
-            this._recentServiceIds.push(id);
+        if (!this.recentlyUsedServices.includes(id)) {
+            this.recentlyUsedServices.push(id);
         }
         return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
     }
-    retrieve({ key, Codec }, description) {
-        const bytes = this.backend.get(key);
-        if (bytes === null) {
-            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${key}`);
+    retrieve(k, description) {
+        const data = this.retrieveOptional(k);
+        if (data === undefined) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${k.key}`);
         }
-        return Decoder.decodeObject(Codec, bytes, this.spec);
+        return data;
     }
     retrieveOptional({ key, Codec }) {
+        const cached = this.dataCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
         const bytes = this.backend.get(key);
         if (bytes === null) {
             return undefined;
         }
-        return Decoder.decodeObject(Codec, bytes, this.spec);
+        const data = Decoder.decodeObject(Codec, bytes, this.spec);
+        this.dataCache.set(key, data);
+        return data;
     }
     get availabilityAssignment() {
         return this.retrieve(serialize.availabilityAssignment, "availabilityAssignment");
@@ -34736,6 +34911,7 @@ function loadState(spec, blake2b, entries) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/database/leaf-db.ts
 
 
@@ -34894,7 +35070,7 @@ const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH
 const lookupHistoryItemCodec = descriptors_codec.object({
     hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
     length: descriptors_codec.u32,
-    slots: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32.asOpaque())).convert(seeThrough, service_tryAsLookupHistorySlots),
+    slots: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32.asOpaque())).convert(seeThrough, service_tryAsLookupHistorySlots),
 }, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
 const lookupHistoryEntryCodec = descriptors_codec.object({
     key: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
@@ -34937,47 +35113,51 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const in_memory_state_codec_inMemoryStateCodec = descriptors_codec.Class(InMemoryState, {
+const in_memory_state_codec_inMemoryStateCodec = (spec) => codec.Class(class State extends InMemoryState {
+    static create(data) {
+        return InMemoryState.new(spec, data);
+    }
+}, {
     // alpha
-    authPools: serialize_serialize.authPools.Codec,
+    authPools: serialize.authPools.Codec,
     // phi
-    authQueues: serialize_serialize.authQueues.Codec,
+    authQueues: serialize.authQueues.Codec,
     // beta
-    recentBlocks: serialize_serialize.recentBlocks.Codec,
+    recentBlocks: serialize.recentBlocks.Codec,
     // gamma_k
     nextValidatorData: codecPerValidator(ValidatorData.Codec),
     // gamma_z
-    epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+    epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
     // gamma_s
     sealingKeySeries: SafroleSealingKeysData.Codec,
     // gamma_a
-    ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert((x) => x, sized_array_asKnownSize),
+    ticketsAccumulator: readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert((x) => x, asKnownSize),
     // psi
-    disputesRecords: serialize_serialize.disputesRecords.Codec,
+    disputesRecords: serialize.disputesRecords.Codec,
     // eta
-    entropy: serialize_serialize.entropy.Codec,
+    entropy: serialize.entropy.Codec,
     // iota
-    designatedValidatorData: serialize_serialize.designatedValidators.Codec,
+    designatedValidatorData: serialize.designatedValidators.Codec,
     // kappa
-    currentValidatorData: serialize_serialize.currentValidators.Codec,
+    currentValidatorData: serialize.currentValidators.Codec,
     // lambda
-    previousValidatorData: serialize_serialize.previousValidators.Codec,
+    previousValidatorData: serialize.previousValidators.Codec,
     // rho
-    availabilityAssignment: serialize_serialize.availabilityAssignment.Codec,
+    availabilityAssignment: serialize.availabilityAssignment.Codec,
     // tau
-    timeslot: serialize_serialize.timeslot.Codec,
+    timeslot: serialize.timeslot.Codec,
     // chi
-    privilegedServices: serialize_serialize.privilegedServices.Codec,
+    privilegedServices: serialize.privilegedServices.Codec,
     // pi
-    statistics: serialize_serialize.statistics.Codec,
+    statistics: serialize.statistics.Codec,
     // omega
-    accumulationQueue: serialize_serialize.accumulationQueue.Codec,
+    accumulationQueue: serialize.accumulationQueue.Codec,
     // xi
-    recentlyAccumulated: serialize_serialize.recentlyAccumulated.Codec,
+    recentlyAccumulated: serialize.recentlyAccumulated.Codec,
     // theta
-    accumulationOutputLog: serialize_serialize.accumulationOutputLog.Codec,
+    accumulationOutputLog: serialize.accumulationOutputLog.Codec,
     // delta
-    services: descriptors_codec.dictionary(descriptors_codec.u32.asOpaque(), ServiceWithCodec.Codec, {
+    services: codec.dictionary(codec.u32.asOpaque(), ServiceWithCodec.Codec, {
         sortKeys: (a, b) => a - b,
     }),
 });
@@ -35024,7 +35204,7 @@ class InMemoryStates {
     }
     /** Insert a full state into the database. */
     async insertState(headerHash, state) {
-        const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
+        const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
         this.db.set(headerHash, encoded);
         return Result.ok(OK);
     }
@@ -35033,7 +35213,7 @@ class InMemoryStates {
         if (encodedState === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
+        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
     }
 }