@typeberry/jam 0.2.0-b6e3410 → 0.2.0-c3df163

package/index.js

@@ -26373,6 +26373,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.
@@ -26505,7 +26508,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)}
@@ -26667,7 +26670,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.
      *
@@ -27489,7 +27500,7 @@ const BANDERSNATCH_KEY_BYTES = 32;
 /** Bandersnatch VRF signature size */
 const 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. */
@@ -29070,9 +29081,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) => {
@@ -29446,16 +29457,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(
     /**
@@ -29567,7 +29578,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,
     });
@@ -29694,7 +29705,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 }) {
@@ -30386,7 +30397,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, {
@@ -30400,7 +30411,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(),
 });
@@ -30521,7 +30532,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);
@@ -30545,7 +30556,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);
@@ -30817,6 +30828,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
 
 
@@ -30835,6 +30859,7 @@ function emptyBlock(slot = tryAsTimeSlot(0)) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/block-json/disputes-extrinsic.ts
 
 
@@ -31074,7 +31099,7 @@ const epochMark = json.object({
 const ticket = json.object({
     id: fromJson.bytes32(),
     attempt: fromJson.ticketAttempt,
-}, (x) => Ticket.create({ id: x.id, attempt: x.attempt }));
+}, (x) => tickets_Ticket.create({ id: x.id, attempt: x.attempt }));
 const headerFromJson = json.object({
     parent: fromJson.bytes32(),
     parent_state_root: fromJson.bytes32(),
@@ -31999,10 +32024,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.isGreaterOrEqual(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 = 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.
  *
@@ -32031,27 +32175,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 SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -32113,65 +32260,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 = 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));
@@ -32179,7 +32267,7 @@ const MIN_VALUE = -(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
 
 
 
@@ -32187,28 +32275,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 SafroleData {
+    nextValidatorData;
+    epochRoot;
+    sealingKeySeries;
+    ticketsAccumulator;
+    static Codec = descriptors_codec.Class(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 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", {
@@ -32369,358 +32701,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.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, 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.isGreaterOrEqual(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) => numbers_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.isGreaterOrEqual(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.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: {
+            [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,
+            }),
+            [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 = SafroleData.create({
+            nextValidatorData: this.state.nextValidatorData,
+            epochRoot: this.state.epochRoot,
+            sealingKeySeries: this.state.sealingKeySeries,
+            ticketsAccumulator: this.state.ticketsAccumulator,
+        });
+        return reencodeAsView(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}`);
-        });
+
+/** 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 keys(keys) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
-    }
-    static tickets(tickets) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
+    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 SafroleData {
-    nextValidatorData;
-    epochRoot;
-    sealingKeySeries;
-    ticketsAccumulator;
-    static Codec = descriptors_codec.Class(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.isGreaterOrEqual(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 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;
     }
 }
 
@@ -32849,311 +33241,39 @@ class UpdateService {
 var UpdateStorageKind;
 (function (UpdateStorageKind) {
     /** Set a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
-    /** Remove a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
-})(UpdateStorageKind || (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: UpdateStorageKind.Set, storage });
-    }
-    static remove({ serviceId, key }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
-    }
-    get key() {
-        if (this.action.kind === UpdateStorageKind.Remove) {
-            return this.action.key;
-        }
-        return this.action.storage.key;
-    }
-    get value() {
-        if (this.action.kind === UpdateStorageKind.Remove) {
-            return null;
-        }
-        return this.action.storage.value;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/jam/state/statistics.ts
-
-
-
-
-
-
-const codecServiceId = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, 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) => numbers_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.isGreaterOrEqual(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);
-    }
-}
+    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
+    /** Remove a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
+})(UpdateStorageKind || (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.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: {
-            [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,
-            }),
-            [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: 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: 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 === 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 === UpdateStorageKind.Remove) {
+            return null;
+        }
+        return this.action.storage.value;
     }
 }
 
@@ -33178,6 +33298,7 @@ class StatisticsData {
 
 
 
+
 
 
 var in_memory_state_UpdateError;
@@ -33278,10 +33399,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.
@@ -33290,14 +33412,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);
@@ -33307,7 +33429,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,
@@ -33504,8 +33626,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;
@@ -33527,31 +33650,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(),
@@ -33567,7 +33693,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),
@@ -33577,8 +33703,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),
@@ -33618,50 +33744,9 @@ 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
 
@@ -33675,26 +33760,19 @@ class NotYetAccumulatedReport extends WithDebug {
 
 
 
-
-
-
 /** Serialization for particular state entries. */
-var serialize;
+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,
     };
     /**
@@ -33703,7 +33781,7 @@ var 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 */
@@ -33732,25 +33810,25 @@ var 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 */
@@ -33774,13 +33852,13 @@ var 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 */
@@ -33809,9 +33887,9 @@ var serialize;
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
         key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
-        Codec: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32)),
+        Codec: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32)),
     });
-})(serialize || (serialize = {}));
+})(serialize_serialize || (serialize_serialize = {}));
 /**
  * Just dump the entire terminal blob as-is.
  *
@@ -33821,6 +33899,87 @@ var 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 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_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_serialize.availabilityAssignment, "availabilityAssignmentView");
+    }
+    designatedValidatorDataView() {
+        return this.retrieveView(serialize_serialize.designatedValidators, "designatedValidatorsView");
+    }
+    currentValidatorDataView() {
+        return this.retrieveView(serialize_serialize.currentValidators, "currentValidatorsView");
+    }
+    previousValidatorDataView() {
+        return this.retrieveView(serialize_serialize.previousValidators, "previousValidatorsView");
+    }
+    authPoolsView() {
+        return this.retrieveView(serialize_serialize.authPools, "authPoolsView");
+    }
+    authQueuesView() {
+        return this.retrieveView(serialize_serialize.authQueues, "authQueuesView");
+    }
+    recentBlocksView() {
+        return this.retrieveView(serialize_serialize.recentBlocks, "recentBlocksView");
+    }
+    statisticsView() {
+        return this.retrieveView(serialize_serialize.statistics, "statisticsView");
+    }
+    accumulationQueueView() {
+        return this.retrieveView(serialize_serialize.accumulationQueue, "accumulationQueueView");
+    }
+    recentlyAccumulatedView() {
+        return this.retrieveView(serialize_serialize.recentlyAccumulated, "recentlyAccumulatedView");
+    }
+    safroleDataView() {
+        return this.retrieveView(serialize_serialize.safrole, "safroleDataView");
+    }
+    getServiceInfoView(id) {
+        const serviceData = serialize_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_Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state.ts
 
 
@@ -33829,6 +33988,8 @@ const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) =
 
 
 
+
+
 /**
  * State object which reads it's entries from some backend.
  *
@@ -33841,7 +34002,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);
@@ -33850,106 +34011,120 @@ class serialized_state_SerializedState {
     static new(spec, blake2b, db, recentServices = []) {
         return new serialized_state_SerializedState(spec, blake2b, db, recentServices);
     }
+    dataCache = hash_dictionary_HashDictionary.new();
+    viewCache = hash_dictionary_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 = hash_dictionary_HashDictionary.new();
+        this.viewCache = hash_dictionary_HashDictionary.new();
     }
     recentServiceIds() {
-        return this._recentServiceIds;
+        return this.recentlyUsedServices;
     }
     getService(id) {
-        const serviceData = this.retrieveOptional(serialize.serviceData(id));
+        const serviceData = this.retrieveOptional(serialize_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_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_Decoder.decodeObject(Codec, bytes, this.spec);
+        const data = decoder_Decoder.decodeObject(Codec, bytes, this.spec);
+        this.dataCache.set(key, data);
+        return data;
     }
     get availabilityAssignment() {
-        return this.retrieve(serialize.availabilityAssignment, "availabilityAssignment");
+        return this.retrieve(serialize_serialize.availabilityAssignment, "availabilityAssignment");
     }
     get designatedValidatorData() {
-        return this.retrieve(serialize.designatedValidators, "designatedValidatorData");
+        return this.retrieve(serialize_serialize.designatedValidators, "designatedValidatorData");
     }
     get nextValidatorData() {
-        return this.retrieve(serialize.safrole, "safroleData.nextValidatorData").nextValidatorData;
+        return this.retrieve(serialize_serialize.safrole, "safroleData.nextValidatorData").nextValidatorData;
     }
     get currentValidatorData() {
-        return this.retrieve(serialize.currentValidators, "currentValidators");
+        return this.retrieve(serialize_serialize.currentValidators, "currentValidators");
     }
     get previousValidatorData() {
-        return this.retrieve(serialize.previousValidators, "previousValidators");
+        return this.retrieve(serialize_serialize.previousValidators, "previousValidators");
     }
     get disputesRecords() {
-        return this.retrieve(serialize.disputesRecords, "disputesRecords");
+        return this.retrieve(serialize_serialize.disputesRecords, "disputesRecords");
     }
     get timeslot() {
-        return this.retrieve(serialize.timeslot, "timeslot");
+        return this.retrieve(serialize_serialize.timeslot, "timeslot");
     }
     get entropy() {
-        return this.retrieve(serialize.entropy, "entropy");
+        return this.retrieve(serialize_serialize.entropy, "entropy");
     }
     get authPools() {
-        return this.retrieve(serialize.authPools, "authPools");
+        return this.retrieve(serialize_serialize.authPools, "authPools");
     }
     get authQueues() {
-        return this.retrieve(serialize.authQueues, "authQueues");
+        return this.retrieve(serialize_serialize.authQueues, "authQueues");
     }
     get recentBlocks() {
-        return this.retrieve(serialize.recentBlocks, "recentBlocks");
+        return this.retrieve(serialize_serialize.recentBlocks, "recentBlocks");
     }
     get statistics() {
-        return this.retrieve(serialize.statistics, "statistics");
+        return this.retrieve(serialize_serialize.statistics, "statistics");
     }
     get accumulationQueue() {
-        return this.retrieve(serialize.accumulationQueue, "accumulationQueue");
+        return this.retrieve(serialize_serialize.accumulationQueue, "accumulationQueue");
     }
     get recentlyAccumulated() {
-        return this.retrieve(serialize.recentlyAccumulated, "recentlyAccumulated");
+        return this.retrieve(serialize_serialize.recentlyAccumulated, "recentlyAccumulated");
     }
     get ticketsAccumulator() {
-        return this.retrieve(serialize.safrole, "safroleData.ticketsAccumulator").ticketsAccumulator;
+        return this.retrieve(serialize_serialize.safrole, "safroleData.ticketsAccumulator").ticketsAccumulator;
     }
     get sealingKeySeries() {
-        return this.retrieve(serialize.safrole, "safrole.sealingKeySeries").sealingKeySeries;
+        return this.retrieve(serialize_serialize.safrole, "safrole.sealingKeySeries").sealingKeySeries;
     }
     get epochRoot() {
-        return this.retrieve(serialize.safrole, "safrole.epochRoot").epochRoot;
+        return this.retrieve(serialize_serialize.safrole, "safrole.epochRoot").epochRoot;
     }
     get privilegedServices() {
-        return this.retrieve(serialize.privilegedServices, "privilegedServices");
+        return this.retrieve(serialize_serialize.privilegedServices, "privilegedServices");
     }
     get accumulationOutputLog() {
-        return this.retrieve(serialize.accumulationOutputLog, "accumulationOutputLog");
+        return this.retrieve(serialize_serialize.accumulationOutputLog, "accumulationOutputLog");
     }
 }
 /** Service data representation on a serialized state. */
@@ -33978,9 +34153,9 @@ class SerializedService {
             serviceIdAndKey.set(numbers_u32AsLeBytes(this.serviceId));
             serviceIdAndKey.set(rawKey.raw, SERVICE_ID_BYTES);
             const key = opaque_asOpaqueType(bytes_BytesBlob.blobFrom(this.blake2b.hashBytes(serviceIdAndKey).raw));
-            return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, key)) ?? null;
+            return this.retrieveOptional(serialize_serialize.serviceStorage(this.blake2b, this.serviceId, key)) ?? null;
         }
-        return this.retrieveOptional(serialize.serviceStorage(this.blake2b, this.serviceId, rawKey)) ?? null;
+        return this.retrieveOptional(serialize_serialize.serviceStorage(this.blake2b, this.serviceId, rawKey)) ?? null;
     }
     /**
      * Check if preimage is present in the DB.
@@ -33989,15 +34164,15 @@ class SerializedService {
      */
     hasPreimage(hash) {
         // TODO [ToDr] consider optimizing to avoid fetching the whole data.
-        return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) !== undefined;
+        return this.retrieveOptional(serialize_serialize.servicePreimages(this.blake2b, this.serviceId, hash)) !== undefined;
     }
     /** Retrieve preimage from the DB. */
     getPreimage(hash) {
-        return this.retrieveOptional(serialize.servicePreimages(this.blake2b, this.serviceId, hash)) ?? null;
+        return this.retrieveOptional(serialize_serialize.servicePreimages(this.blake2b, this.serviceId, hash)) ?? null;
     }
     /** Retrieve preimage lookup history. */
     getLookupHistory(hash, len) {
-        const rawSlots = this.retrieveOptional(serialize.serviceLookupHistory(this.blake2b, this.serviceId, hash, len));
+        const rawSlots = this.retrieveOptional(serialize_serialize.serviceLookupHistory(this.blake2b, this.serviceId, hash, len));
         if (rawSlots === undefined) {
             return null;
         }
@@ -34686,7 +34861,7 @@ function* serializeStateUpdate(spec, blake2b, update) {
 function* serializeRemovedServices(servicesRemoved) {
     for (const serviceId of servicesRemoved ?? []) {
         // TODO [ToDr] what about all data associated with a service?
-        const codec = serialize.serviceData(serviceId);
+        const codec = serialize_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
     }
 }
@@ -34695,13 +34870,13 @@ function* serializeStorage(storage, blake2b) {
         switch (action.kind) {
             case UpdateStorageKind.Set: {
                 const key = action.storage.key;
-                const codec = serialize.serviceStorage(blake2b, serviceId, key);
+                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
                 yield [StateEntryUpdateAction.Insert, codec.key, action.storage.value];
                 break;
             }
             case UpdateStorageKind.Remove: {
                 const key = action.key;
-                const codec = serialize.serviceStorage(blake2b, serviceId, key);
+                const codec = serialize_serialize.serviceStorage(blake2b, serviceId, key);
                 yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
                 break;
             }
@@ -34715,10 +34890,10 @@ function* serializePreimages(preimages, encode, blake2b) {
         switch (action.kind) {
             case UpdatePreimageKind.Provide: {
                 const { hash, blob } = action.preimage;
-                const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+                const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
                 yield [StateEntryUpdateAction.Insert, codec.key, blob];
                 if (action.slot !== null) {
-                    const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
+                    const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, numbers_tryAsU32(blob.length));
                     yield [
                         StateEntryUpdateAction.Insert,
                         codec2.key,
@@ -34729,15 +34904,15 @@ function* serializePreimages(preimages, encode, blake2b) {
             }
             case UpdatePreimageKind.UpdateOrAdd: {
                 const { hash, length, slots } = action.item;
-                const codec = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                const codec = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
                 yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, slots)];
                 break;
             }
             case UpdatePreimageKind.Remove: {
                 const { hash, length } = action;
-                const codec = serialize.servicePreimages(blake2b, serviceId, hash);
+                const codec = serialize_serialize.servicePreimages(blake2b, serviceId, hash);
                 yield [StateEntryUpdateAction.Remove, codec.key, EMPTY_BLOB];
-                const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
+                const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, hash, length);
                 yield [StateEntryUpdateAction.Remove, codec2.key, EMPTY_BLOB];
                 break;
             }
@@ -34749,12 +34924,12 @@ function* serializePreimages(preimages, encode, blake2b) {
 function* serializeServiceUpdates(servicesUpdates, encode, blake2b) {
     for (const { action, serviceId } of servicesUpdates ?? []) {
         // new service being created or updated
-        const codec = serialize.serviceData(serviceId);
+        const codec = serialize_serialize.serviceData(serviceId);
         yield [StateEntryUpdateAction.Insert, codec.key, encode(codec.Codec, action.account)];
         // additional lookup history update
         if (action.kind === UpdateServiceKind.Create && action.lookupHistory !== null) {
             const { lookupHistory } = action;
-            const codec2 = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
+            const codec2 = serialize_serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
             yield [StateEntryUpdateAction.Insert, codec2.key, encode(codec2.Codec, lookupHistory.slots)];
         }
     }
@@ -34764,53 +34939,53 @@ function* serializeBasicKeys(spec, update) {
         return [StateEntryUpdateAction.Insert, codec.key, encoder_Encoder.encodeObject(codec.Codec, val, spec)];
     }
     if (update.authPools !== undefined) {
-        yield doSerialize(update.authPools, serialize.authPools); // C(1)
+        yield doSerialize(update.authPools, serialize_serialize.authPools); // C(1)
     }
     if (update.authQueues !== undefined) {
-        yield doSerialize(update.authQueues, serialize.authQueues); // C(2)
+        yield doSerialize(update.authQueues, serialize_serialize.authQueues); // C(2)
     }
     if (update.recentBlocks !== undefined) {
-        yield doSerialize(update.recentBlocks, serialize.recentBlocks); // C(3)
+        yield doSerialize(update.recentBlocks, serialize_serialize.recentBlocks); // C(3)
     }
     const safroleData = getSafroleData(update.nextValidatorData, update.epochRoot, update.sealingKeySeries, update.ticketsAccumulator);
     if (safroleData !== undefined) {
-        yield doSerialize(safroleData, serialize.safrole); // C(4)
+        yield doSerialize(safroleData, serialize_serialize.safrole); // C(4)
     }
     if (update.disputesRecords !== undefined) {
-        yield doSerialize(update.disputesRecords, serialize.disputesRecords); // C(5)
+        yield doSerialize(update.disputesRecords, serialize_serialize.disputesRecords); // C(5)
     }
     if (update.entropy !== undefined) {
-        yield doSerialize(update.entropy, serialize.entropy); // C(6)
+        yield doSerialize(update.entropy, serialize_serialize.entropy); // C(6)
     }
     if (update.designatedValidatorData !== undefined) {
-        yield doSerialize(update.designatedValidatorData, serialize.designatedValidators); // C(7)
+        yield doSerialize(update.designatedValidatorData, serialize_serialize.designatedValidators); // C(7)
     }
     if (update.currentValidatorData !== undefined) {
-        yield doSerialize(update.currentValidatorData, serialize.currentValidators); // C(8)
+        yield doSerialize(update.currentValidatorData, serialize_serialize.currentValidators); // C(8)
     }
     if (update.previousValidatorData !== undefined) {
-        yield doSerialize(update.previousValidatorData, serialize.previousValidators); // C(9)
+        yield doSerialize(update.previousValidatorData, serialize_serialize.previousValidators); // C(9)
     }
     if (update.availabilityAssignment !== undefined) {
-        yield doSerialize(update.availabilityAssignment, serialize.availabilityAssignment); // C(10)
+        yield doSerialize(update.availabilityAssignment, serialize_serialize.availabilityAssignment); // C(10)
     }
     if (update.timeslot !== undefined) {
-        yield doSerialize(update.timeslot, serialize.timeslot); // C(11)
+        yield doSerialize(update.timeslot, serialize_serialize.timeslot); // C(11)
     }
     if (update.privilegedServices !== undefined) {
-        yield doSerialize(update.privilegedServices, serialize.privilegedServices); // C(12)
+        yield doSerialize(update.privilegedServices, serialize_serialize.privilegedServices); // C(12)
     }
     if (update.statistics !== undefined) {
-        yield doSerialize(update.statistics, serialize.statistics); // C(13)
+        yield doSerialize(update.statistics, serialize_serialize.statistics); // C(13)
     }
     if (update.accumulationQueue !== undefined) {
-        yield doSerialize(update.accumulationQueue, serialize.accumulationQueue); // C(14)
+        yield doSerialize(update.accumulationQueue, serialize_serialize.accumulationQueue); // C(14)
     }
     if (update.recentlyAccumulated !== undefined) {
-        yield doSerialize(update.recentlyAccumulated, serialize.recentlyAccumulated); // C(15)
+        yield doSerialize(update.recentlyAccumulated, serialize_serialize.recentlyAccumulated); // C(15)
     }
     if (update.accumulationOutputLog !== undefined) {
-        yield doSerialize(update.accumulationOutputLog, serialize.accumulationOutputLog); // C(16)
+        yield doSerialize(update.accumulationOutputLog, serialize_serialize.accumulationOutputLog); // C(16)
     }
 }
 function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator) {
@@ -34923,41 +35098,41 @@ function convertInMemoryStateToDictionary(spec, blake2b, state) {
     function doSerialize(codec) {
         serialized.set(codec.key, encoder_Encoder.encodeObject(codec.Codec, codec.extract(state), spec));
     }
-    doSerialize(serialize.authPools); // C(1)
-    doSerialize(serialize.authQueues); // C(2)
-    doSerialize(serialize.recentBlocks); // C(3)
-    doSerialize(serialize.safrole); // C(4)
-    doSerialize(serialize.disputesRecords); // C(5)
-    doSerialize(serialize.entropy); // C(6)
-    doSerialize(serialize.designatedValidators); // C(7)
-    doSerialize(serialize.currentValidators); // C(8)
-    doSerialize(serialize.previousValidators); // C(9)
-    doSerialize(serialize.availabilityAssignment); // C(10)
-    doSerialize(serialize.timeslot); // C(11)
-    doSerialize(serialize.privilegedServices); // C(12)
-    doSerialize(serialize.statistics); // C(13)
-    doSerialize(serialize.accumulationQueue); // C(14)
-    doSerialize(serialize.recentlyAccumulated); // C(15)
-    doSerialize(serialize.accumulationOutputLog); // C(16)
+    doSerialize(serialize_serialize.authPools); // C(1)
+    doSerialize(serialize_serialize.authQueues); // C(2)
+    doSerialize(serialize_serialize.recentBlocks); // C(3)
+    doSerialize(serialize_serialize.safrole); // C(4)
+    doSerialize(serialize_serialize.disputesRecords); // C(5)
+    doSerialize(serialize_serialize.entropy); // C(6)
+    doSerialize(serialize_serialize.designatedValidators); // C(7)
+    doSerialize(serialize_serialize.currentValidators); // C(8)
+    doSerialize(serialize_serialize.previousValidators); // C(9)
+    doSerialize(serialize_serialize.availabilityAssignment); // C(10)
+    doSerialize(serialize_serialize.timeslot); // C(11)
+    doSerialize(serialize_serialize.privilegedServices); // C(12)
+    doSerialize(serialize_serialize.statistics); // C(13)
+    doSerialize(serialize_serialize.accumulationQueue); // C(14)
+    doSerialize(serialize_serialize.recentlyAccumulated); // C(15)
+    doSerialize(serialize_serialize.accumulationOutputLog); // C(16)
     // services
     for (const [serviceId, service] of state.services.entries()) {
         // data
-        const { key, Codec } = serialize.serviceData(serviceId);
+        const { key, Codec } = serialize_serialize.serviceData(serviceId);
         serialized.set(key, encoder_Encoder.encodeObject(Codec, service.getInfo()));
         // preimages
         for (const preimage of service.data.preimages.values()) {
-            const { key, Codec } = serialize.servicePreimages(blake2b, serviceId, preimage.hash);
+            const { key, Codec } = serialize_serialize.servicePreimages(blake2b, serviceId, preimage.hash);
             serialized.set(key, encoder_Encoder.encodeObject(Codec, preimage.blob));
         }
         // storage
         for (const storage of service.data.storage.values()) {
-            const { key, Codec } = serialize.serviceStorage(blake2b, serviceId, storage.key);
+            const { key, Codec } = serialize_serialize.serviceStorage(blake2b, serviceId, storage.key);
             serialized.set(key, encoder_Encoder.encodeObject(Codec, storage.value));
         }
         // lookup history
         for (const lookupHistoryList of service.data.lookupHistory.values()) {
             for (const lookupHistory of lookupHistoryList) {
-                const { key, Codec } = serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
+                const { key, Codec } = serialize_serialize.serviceLookupHistory(blake2b, serviceId, lookupHistory.hash, lookupHistory.length);
                 serialized.set(key, encoder_Encoder.encodeObject(Codec, lookupHistory.slots.slice()));
             }
         }
@@ -35007,6 +35182,7 @@ function loadState(spec, blake2b, entries) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/database/leaf-db.ts
 
 
@@ -35165,7 +35341,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, tryAsLookupHistorySlots),
+    slots: descriptors_readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.u32.asOpaque())).convert(seeThrough, tryAsLookupHistorySlots),
 }, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
 const lookupHistoryEntryCodec = descriptors_codec.object({
     key: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
@@ -35208,7 +35384,11 @@ 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.authPools.Codec,
     // phi
@@ -35218,11 +35398,11 @@ const in_memory_state_codec_inMemoryStateCodec = descriptors_codec.Class(InMemor
     // 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.disputesRecords.Codec,
     // eta
@@ -35248,7 +35428,7 @@ const in_memory_state_codec_inMemoryStateCodec = descriptors_codec.Class(InMemor
     // theta
     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,
     }),
 });
@@ -35295,7 +35475,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);
     }
@@ -35304,7 +35484,7 @@ class InMemoryStates {
         if (encodedState === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
+        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
     }
 }
 
@@ -35530,14 +35710,14 @@ async function initializeDatabase(spec, blake2b, genesisHeaderHash, rootDb, conf
     const genesisHeader = decoder_Decoder.decodeObject(Header.Codec, config.genesisHeader, spec);
     const genesisExtrinsic = emptyBlock().extrinsic;
     const genesisBlock = Block.create({ header: genesisHeader, extrinsic: genesisExtrinsic });
-    const blockView = blockAsView(genesisBlock, spec);
+    const blockView = reencodeAsView(Block.Codec, genesisBlock, spec);
     common_logger.log `🧬 Writing genesis block #${genesisHeader.timeSlotIndex}: ${genesisHeaderHash}`;
     const { genesisStateSerialized, genesisStateRootHash } = loadGenesisState(spec, blake2b, config.genesisState);
     // write to db
     await blocks.insertBlock(new WithHash(genesisHeaderHash, blockView));
     // insert fake blocks for ancestry data
     for (const [hash, slot] of ancestry) {
-        await blocks.insertBlock(new WithHash(hash, blockAsView(emptyBlock(slot), spec)));
+        await blocks.insertBlock(new WithHash(hash, reencodeAsView(Block.Codec, emptyBlock(slot), spec)));
     }
     await states.insertState(genesisHeaderHash, genesisStateSerialized);
     await blocks.setPostStateRoot(genesisHeaderHash, genesisStateRootHash);
@@ -35556,9 +35736,6 @@ function loadGenesisState(spec, blake2b, data) {
         genesisStateRootHash,
     };
 }
-function blockAsView(block, spec) {
-    return decoder_Decoder.decodeObject(Block.Codec.View, encoder_Encoder.encodeObject(Block.Codec, block, spec), spec);
-}
 
 ;// CONCATENATED MODULE: external "node:path"
 const external_node_path_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:path");
@@ -36748,21 +36925,21 @@ class TransitionHasher {
      */
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-        const guarantees = extrinsicView.guarantees
+        const guaranteesCount = numbers_tryAsU32(extrinsicView.guarantees.view().length);
+        const countEncoded = encoder_Encoder.encodeObject(descriptors_codec.varU32, guaranteesCount);
+        const guaranteesBlobs = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
-            .map((guarantee) => {
+            .reduce((aggregated, guarantee) => {
             const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque();
-            return bytes_BytesBlob.blobFromParts([
-                reportHash.raw,
-                guarantee.slot.encoded().raw,
-                guarantee.credentials.encoded().raw,
-            ]);
-        });
-        const guaranteeBlob = encoder_Encoder.encodeObject(descriptors_codec.sequenceVarLen(dumpCodec), guarantees, this.context);
+            aggregated.push(reportHash.raw);
+            aggregated.push(guarantee.slot.encoded().raw);
+            aggregated.push(guarantee.credentials.encoded().raw);
+            return aggregated;
+        }, [countEncoded.raw]);
         const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque();
         const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque();
-        const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque();
+        const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque();
         const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
         const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
         const encoded = bytes_BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
@@ -41378,7 +41555,7 @@ async function getRingCommitmentNoCache(bandersnatch, keys) {
     if (commitmentResult[RESULT_INDEX] === ResultValues.Error) {
         return result_Result.error(null);
     }
-    return result_Result.ok(bytes_Bytes.fromBlob(commitmentResult.subarray(1), BANDERSNATCH_RING_ROOT_BYTES).asOpaque());
+    return result_Result.ok(bytes_Bytes.fromBlob(commitmentResult.subarray(1), bandersnatch_BANDERSNATCH_RING_ROOT_BYTES).asOpaque());
 }
 // One byte for result discriminator (`ResultValues`) and the rest is entropy hash.
 const TICKET_RESULT_LENGTH = 1 + hash_HASH_SIZE;
@@ -41532,7 +41709,7 @@ class Safrole {
              * https://graypaper.fluffylabs.dev/#/5f542d7/0ea2000ea200
              */
             if (isOffender) {
-                return ValidatorData.create({
+                return validator_data_ValidatorData.create({
                     bandersnatch: bytes_Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
                     ed25519: bytes_Bytes.zero(ED25519_KEY_BYTES).asOpaque(),
                     bls: bytes_Bytes.zero(BLS_KEY_BYTES).asOpaque(),
@@ -41610,13 +41787,13 @@ class Safrole {
         if (this.isNextEpoch(timeslot) &&
             m >= this.chainSpec.contestLength &&
             this.state.ticketsAccumulator.length === this.chainSpec.epochLength) {
-            return SafroleSealingKeysData.tickets(this.outsideInSequencer(this.state.ticketsAccumulator).tickets);
+            return safrole_data_SafroleSealingKeysData.tickets(this.outsideInSequencer(this.state.ticketsAccumulator).tickets);
         }
         if (this.isSameEpoch(timeslot)) {
             return this.state.sealingKeySeries;
         }
         // TODO [MaSi]: the result of fallback sequencer should be cached
-        return SafroleSealingKeysData.keys(this.fallbackKeySequencer(newEntropy, newValidators));
+        return safrole_data_SafroleSealingKeysData.keys(this.fallbackKeySequencer(newEntropy, newValidators));
     }
     /**
      * Returns epoch markers if the epoch is changed and null otherwise
@@ -41866,47 +42043,46 @@ class SafroleSeal {
     }
     async verifySeal(headerView, state) {
         // we use transitioned keys already
-        const validators = state.currentValidatorData;
         const validatorIndex = headerView.bandersnatchBlockAuthorIndex.materialize();
-        const authorKey = validators[validatorIndex];
-        if (authorKey === undefined) {
+        const authorKeys = state.currentValidatorData.at(validatorIndex);
+        if (authorKeys === undefined) {
             return result_Result.error(SafroleSealError.InvalidValidatorIndex);
         }
         const timeSlot = headerView.timeSlotIndex.materialize();
         const sealingKeys = state.sealingKeySeries;
         const entropy = state.currentEntropy;
         if (sealingKeys.kind === SafroleSealingKeysKind.Tickets) {
-            return await this.verifySealWithTicket(sealingKeys.tickets, timeSlot, entropy, validators, validatorIndex, headerView);
+            return await this.verifySealWithTicket(sealingKeys.tickets, timeSlot, entropy, authorKeys, headerView);
         }
-        return await this.verifySealWithKeys(sealingKeys.keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView);
+        return await this.verifySealWithKeys(sealingKeys.keys, timeSlot, entropy, authorKeys, headerView);
     }
     /** Regular (non-fallback) mode of Safrole. */
-    async verifySealWithTicket(tickets, timeSlot, entropy, validators, validatorIndex, headerView) {
+    async verifySealWithTicket(tickets, timeSlot, entropy, validatorData, headerView) {
         const index = timeSlot % tickets.length;
-        const { id, attempt } = tickets[index];
-        const payload = bytes_BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt]));
+        const ticket = tickets.at(index);
+        const payload = bytes_BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([ticket?.attempt ?? 0]));
         // verify seal correctness
-        const authorKey = validators.at(validatorIndex)?.bandersnatch;
+        const authorKey = validatorData.bandersnatch;
         const result = await bandersnatch_vrf.verifySeal(await this.bandersnatch, authorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return result_Result.error(SafroleSealError.IncorrectSeal);
         }
-        if (!id.isEqualTo(result.ok)) {
+        if (ticket === undefined || !ticket.id.isEqualTo(result.ok)) {
             return result_Result.error(SafroleSealError.InvalidTicket);
         }
         return result_Result.ok(result.ok);
     }
     /** Fallback mode of Safrole. */
-    async verifySealWithKeys(keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView) {
+    async verifySealWithKeys(keys, timeSlot, entropy, authorKey, headerView) {
         const index = timeSlot % keys.length;
-        const sealingKey = keys[index];
-        if (!sealingKey.isEqualTo(authorKey.bandersnatch)) {
+        const sealingKey = keys.at(index);
+        const authorBandersnatchKey = authorKey.bandersnatch;
+        if (sealingKey === undefined || !sealingKey.isEqualTo(authorBandersnatchKey)) {
             return result_Result.error(SafroleSealError.InvalidValidator, `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
         }
         // verify seal correctness
         const payload = bytes_BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw);
-        const blockAuthorKey = validators.at(validatorIndex)?.bandersnatch;
-        const result = await bandersnatch_vrf.verifySeal(await this.bandersnatch, blockAuthorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
+        const result = await bandersnatch_vrf.verifySeal(await this.bandersnatch, authorBandersnatchKey, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return result_Result.error(SafroleSealError.IncorrectSeal);
         }
@@ -47822,9 +47998,6 @@ class HostCallMemory {
         }
         return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
     }
-    getMemory() {
-        return this.memory;
-    }
 }
 
 ;// CONCATENATED MODULE: ./packages/core/pvm-host-calls/host-call-registers.ts
@@ -48103,7 +48276,7 @@ class Assign {
         // NOTE: Here we know the core index is valid
         const coreIndex = tryAsCoreIndex(Number(maybeCoreIndex));
         const decoder = decoder_Decoder.fromBlob(res);
-        const authQueue = decoder.sequenceFixLen(descriptors_codec.bytes(hash_HASH_SIZE), AUTHORIZATION_QUEUE_SIZE);
+        const authQueue = decoder.sequenceFixLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE);
         const fixedSizeAuthQueue = FixedSizeArray.new(authQueue, AUTHORIZATION_QUEUE_SIZE);
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
@@ -48299,7 +48472,7 @@ class Checkpoint {
 
 
 const designate_IN_OUT_REG = 7;
-const VALIDATOR_DATA_BYTES = tryAsExactBytes(ValidatorData.Codec.sizeHint);
+const VALIDATOR_DATA_BYTES = tryAsExactBytes(validator_data_ValidatorData.Codec.sizeHint);
 /**
  * Designate a new set of validator keys.
  *
@@ -48328,7 +48501,7 @@ class Designate {
             return PvmExecution.Panic;
         }
         const decoder = decoder_Decoder.fromBlob(res);
-        const validatorsData = decoder.sequenceFixLen(ValidatorData.Codec, this.chainSpec.validatorsCount);
+        const validatorsData = decoder.sequenceFixLen(validator_data_ValidatorData.Codec, this.chainSpec.validatorsCount);
         const result = this.partialState.updateValidatorsData(tryAsPerValidator(validatorsData, this.chainSpec));
         if (result.isError) {
             logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
@@ -49849,7 +50022,7 @@ class Accumulate {
         }
         const result = await this.pvmAccumulateInvocation(slot, serviceId, transfers, operands, gasCost, entropy, updatedState);
         if (result.isError) {
-            // https://graypaper.fluffylabs.dev/#/7e6ff6a/2fb6012fb601?v=0.6.7
+            // https://graypaper.fluffylabs.dev/#/ab2cdbd/2fc9032fc903?v=0.7.2
             accumulate_logger.log `Accumulation failed for ${serviceId}.`;
             // even though accumulation failed, we still need to make sure that
             // incoming transfers updated the balance, hence we pass state update here
@@ -49943,10 +50116,12 @@ class Accumulate {
             const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getTransfers(serviceId), operands, accumulateData.getGasCost(serviceId), slot, entropy, currentState);
             gasCost = tryAsServiceGas(gasCost + consumedGas);
             // https://graypaper.fluffylabs.dev/#/ab2cdbd/193b05193b05?v=0.7.2
-            // do not update statistics, if the service only had incoming transfers
-            if (operands.length > 0) {
-                const serviceStatistics = statistics.get(serviceId) ?? { count: numbers_tryAsU32(0), gasUsed: tryAsServiceGas(0) };
-                serviceStatistics.count = numbers_tryAsU32(serviceStatistics.count + accumulateData.getReportsLength(serviceId));
+            const serviceStatistics = statistics.get(serviceId) ?? { count: numbers_tryAsU32(0), gasUsed: tryAsServiceGas(0) };
+            const count = accumulateData.getReportsLength(serviceId);
+            // [0.7.1]: do not update statistics, if the service only had incoming transfers
+            if ((Compatibility.isLessThan(GpVersion.V0_7_2) && count > 0) ||
+                (Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) && (count > 0 || consumedGas > 0n))) {
+                serviceStatistics.count = numbers_tryAsU32(serviceStatistics.count + count);
                 serviceStatistics.gasUsed = tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
                 statistics.set(serviceId, serviceStatistics);
             }
@@ -49984,9 +50159,10 @@ class Accumulate {
         const recentlyAccumulated = tryAsPerEpochBlock(newRecentlyAccumulated, this.chainSpec);
         const accumulationQueue = this.state.accumulationQueue.slice();
         accumulationQueue[phaseIndex] = pruneQueue(toAccumulateLater, accumulatedSet);
+        const timeslot = this.state.timeslot;
         for (let i = 1; i < epochLength; i++) {
             const queueIndex = (phaseIndex + epochLength - i) % epochLength;
-            if (i < slot - this.state.timeslot) {
+            if (i < slot - timeslot) {
                 accumulationQueue[queueIndex] = [];
             }
             else {
@@ -50198,7 +50374,6 @@ class DeferredTransfers {
 
 
 
-
 /**
  * Maintain a list of available authorizations per core.
  *
@@ -50227,11 +50402,12 @@ class Authorization {
      */
     transition(input) {
         const authPoolsUpdate = this.state.authPools.slice();
+        const authQueues = this.state.authQueues;
         // we transition authorizations for each core.
         for (let coreIndex = tryAsCoreIndex(0); coreIndex < this.chainSpec.coresCount; coreIndex++) {
             let pool = authPoolsUpdate[coreIndex].slice();
             // the queue is only read (we should most likely use `ArrayView` here).
-            const queue = this.state.authQueues[coreIndex];
+            const queue = authQueues[coreIndex];
             // if there were any used hashes - remove them
             const usedHashes = input.used.get(coreIndex);
             if (usedHashes !== undefined) {
@@ -50405,14 +50581,18 @@ class RecentHistory {
      * https://graypaper.fluffylabs.dev/#/1c979cb/0f55020f5502?v=0.7.1
      */
     partialTransition(input) {
-        const recentBlocks = this.state.recentBlocks.blocks.slice();
+        const stateBlocks = this.state.recentBlocks;
+        const recentBlocks = stateBlocks.blocks.slice();
         const lastState = recentBlocks.length > 0 ? recentBlocks[recentBlocks.length - 1] : null;
         // update the posterior root of previous state.
         if (lastState !== null) {
             lastState.postStateRoot = input.priorStateRoot;
         }
         return {
-            recentBlocks: this.state.recentBlocks.updateBlocks(recentBlocks), // β_H†
+            recentBlocks: RecentBlocks.create({
+                blocks: sized_array_asKnownSize(recentBlocks),
+                accumulationLog: stateBlocks.accumulationLog,
+            }), // β_H†
         };
     }
     /**
@@ -50424,8 +50604,8 @@ class RecentHistory {
     transition(input) {
         const recentBlocks = input.partial.recentBlocks.blocks.slice();
         // `β′_B`
-        const mmr = this.state.recentBlocks.asCurrent().accumulationLog !== null
-            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.asCurrent().accumulationLog)
+        const mmr = this.state.recentBlocks.accumulationLog !== null
+            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.accumulationLog)
             : MerkleMountainRange.empty(this.hasher);
         // append the accumulation root
         mmr.append(input.accumulateRoot);
@@ -50443,7 +50623,7 @@ class RecentHistory {
         }
         // write back to the state.
         return {
-            recentBlocks: RecentBlocksHistory.create(RecentBlocks.create({
+            recentBlocks: RecentBlocks.create(RecentBlocks.create({
                 blocks: sized_array_asKnownSize(recentBlocks),
                 accumulationLog: peaks,
             })),
@@ -50655,7 +50835,6 @@ function verifyReportsBasic(input) {
 
 
 
-
 const verify_contextual_logger = Logger.new(import.meta.filename, "stf:reports");
 /** https://graypaper.fluffylabs.dev/#/7e6ff6a/15eb0115eb01?v=0.6.7 */
 function verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge) {
@@ -50768,7 +50947,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
             return result_Result.error(ReportsError.BadStateRoot, `Anchor state root mismatch. Got: ${context.stateRoot}, expected: ${recentBlock.postStateRoot}.`);
         }
         // check beefy root
-        const beefyRoot = RecentBlocksHistory.accumulationResult(recentBlock);
+        const beefyRoot = recentBlock.accumulationResult;
         if (!beefyRoot.isEqualTo(context.beefyRoot)) {
             return result_Result.error(ReportsError.BadBeefyMmrRoot, `Invalid BEEFY super peak hash. Got: ${context.beefyRoot}, expected: ${beefyRoot}. Anchor: ${recentBlock.headerHash}`);
         }
@@ -51010,8 +51189,9 @@ function verifyPostSignatureChecks(input, availabilityAssignment, authPools, ser
          * https://graypaper.fluffylabs.dev/#/5f542d7/15eb0015ed00
          */
         const authorizerHash = report.authorizerHash;
-        const authorizerPool = authPools[coreIndex];
-        if (authorizerPool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
+        const authorizerPool = authPools.get(coreIndex);
+        const pool = authorizerPool?.materialize() ?? [];
+        if (pool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
             return result_Result.error(ReportsError.CoreUnauthorized, `Authorizer hash not found in the pool of core ${coreIndex}: ${authorizerHash}`);
         }
         /**
@@ -51141,7 +51321,8 @@ class Reports {
         return verifyCredentials(input.guarantees, workReportHashes, input.slot, (headerTimeSlot, guaranteeTimeSlot) => this.getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, input.newEntropy));
     }
     verifyPostSignatureChecks(input, assurancesAvailAssignment) {
-        return verifyPostSignatureChecks(input, assurancesAvailAssignment, this.state.authPools, (id) => this.state.getService(id));
+        const authPoolsView = this.state.view().authPoolsView();
+        return verifyPostSignatureChecks(input, assurancesAvailAssignment, authPoolsView, (id) => this.state.getService(id));
     }
     verifyContextualValidity(input) {
         return verifyContextualValidity(input, this.state, this.headerChain, this.chainSpec.maxLookupAnchorAge);