@typeberry/convert 0.2.0-e767e74 → 0.2.0

package/index.js

@@ -6319,9 +6319,6 @@ 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.
@@ -6616,15 +6613,7 @@ 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) => {
-        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);
-    };
+    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);
     /**
      * A descriptor for a more complex POJO.
      *
@@ -10063,19 +10052,6 @@ function block_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
 
 
@@ -10094,7 +10070,6 @@ function reencodeAsView(codec, object, chainSpec) {
 
 
 
-
 ;// CONCATENATED MODULE: ./packages/core/json-parser/parse.ts
 const NO_KEY = Symbol("no key");
 /** Given already parsed JSON, parse & validate it further to match the expected `jsonDescription` type. */
@@ -11463,128 +11438,10 @@ function accumulation_output_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/#/579bd12/413000413000
- */
-/** `G_I`: The gas allocated to invoke a work-package’s Is-Authorized logic. */
-const gp_constants_G_I = 50_000_000;
-/** `I`: Maximum number of work items in a package. */
-const I = (/* unused pure expression or super */ null && (MAX_NUMBER_OF_WORK_ITEMS));
-/** `O`: Maximum number of items in the authorizations pool. */
-const gp_constants_O = 8;
-/** `Q`: The number of items in the authorizations queue. */
-const gp_constants_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 gp_constants_T = 128;
-/** `W_A`: The maximum size of is-authorized code in octets. */
-const gp_constants_W_A = 64_000;
-/** `W_B`: The maximum size of an encoded work-package with extrinsic data and imports. */
-const gp_constants_W_B = 13_794_305;
-/** `W_C`: The maximum size of service code in octets. */
-const gp_constants_W_C = 4_000_000;
-/** `W_M`: The maximum number of imports in a work-package. */
-const gp_constants_W_M = 3_072;
-/** `W_R`: The maximum total size of all output blobs in a work-report, in octets. */
-const gp_constants_W_R = 49_152;
-/** `W_T`: The size of a transfer memo in octets. */
-const gp_constants_W_T = 128;
-/** `W_M`: The maximum number of exports in a work-package. */
-const gp_constants_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 gp_constants_MIN_PUBLIC_SERVICE_INDEX = (/* unused pure expression or super */ null && (2 ** 16));
-/**
- * `J`: The maximum sum of dependency items in a work-report.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
- */
-const gp_constants_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 accumulation_queue_NotYetAccumulatedReport extends WithDebug {
-    report;
-    dependencies;
-    static Codec = descriptors_codec.Class(accumulation_queue_NotYetAccumulatedReport, {
-        report: work_report_WorkReport.Codec,
-        dependencies: codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
-            typicalLength: gp_constants_MAX_REPORT_DEPENDENCIES / 2,
-            maxLength: gp_constants_MAX_REPORT_DEPENDENCIES,
-            minLength: 0,
-        }),
-    });
-    static create({ report, dependencies }) {
-        return new accumulation_queue_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(readonlyArray(descriptors_codec.sequenceVarLen(accumulation_queue_NotYetAccumulatedReport.Codec)));
-
-;// CONCATENATED MODULE: ./packages/jam/state/common.ts
-
-
-/** Check if given array has correct length before casting to the opaque type. */
-function common_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.
  *
@@ -11613,24 +11470,21 @@ class assurances_AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(descriptors_codec.optional(assurances_AvailabilityAssignment.Codec));
-
-;// CONCATENATED MODULE: ./packages/jam/state/auth.ts
-
-
 
+;// CONCATENATED MODULE: ./packages/jam/state/common.ts
 
 
-/** `O`: Maximal authorization pool size. */
-const auth_MAX_AUTH_POOL_SIZE = gp_constants_O;
-/** `Q`: Size of the authorization queue. */
-const auth_AUTHORIZATION_QUEUE_SIZE = gp_constants_Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
-    minLength: 0,
-    maxLength: auth_MAX_AUTH_POOL_SIZE,
-    typicalLength: auth_MAX_AUTH_POOL_SIZE,
-}));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), auth_AUTHORIZATION_QUEUE_SIZE));
+/** Check if given array has correct length before casting to the opaque type. */
+function common_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/disputes.ts
 
@@ -11698,6 +11552,65 @@ function disputes_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 gp_constants_G_I = 50_000_000;
+/** `I`: Maximum number of work items in a package. */
+const I = (/* unused pure expression or super */ null && (MAX_NUMBER_OF_WORK_ITEMS));
+/** `O`: Maximum number of items in the authorizations pool. */
+const gp_constants_O = 8;
+/** `Q`: The number of items in the authorizations queue. */
+const gp_constants_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 gp_constants_T = 128;
+/** `W_A`: The maximum size of is-authorized code in octets. */
+const gp_constants_W_A = 64_000;
+/** `W_B`: The maximum size of an encoded work-package with extrinsic data and imports. */
+const gp_constants_W_B = 13_794_305;
+/** `W_C`: The maximum size of service code in octets. */
+const gp_constants_W_C = 4_000_000;
+/** `W_M`: The maximum number of imports in a work-package. */
+const gp_constants_W_M = 3_072;
+/** `W_R`: The maximum total size of all output blobs in a work-report, in octets. */
+const gp_constants_W_R = 49_152;
+/** `W_T`: The size of a transfer memo in octets. */
+const gp_constants_W_T = 128;
+/** `W_M`: The maximum number of exports in a work-package. */
+const gp_constants_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 gp_constants_MIN_PUBLIC_SERVICE_INDEX = (/* unused pure expression or super */ null && (2 ** 16));
+/**
+ * `J`: The maximum sum of dependency items in a work-report.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
+ */
+const gp_constants_MAX_REPORT_DEPENDENCIES = 8;
+/** `Q`: Size of the authorization queue. */
+const gp_constants_AUTHORIZATION_QUEUE_SIZE = gp_constants_Q;
+/** `O`: Maximal authorization pool size. */
+const gp_constants_MAX_AUTH_POOL_SIZE = gp_constants_O;
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
 const math_consts_MAX_VALUE = 4294967295;
 const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
@@ -11705,7 +11618,7 @@ const math_consts_MIN_VALUE = (/* unused pure expression or super */ null && (-(
 const math_consts_MAX_SHIFT_U32 = 32;
 const math_consts_MAX_SHIFT_U64 = 64n;
 
-;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
+;// CONCATENATED MODULE: ./packages/jam/state/service.ts
 
 
 
@@ -11713,259 +11626,15 @@ const math_consts_MAX_SHIFT_U64 = 64n;
 
 
 /**
- * `H = 8`: The size of recent history, in blocks.
+ * `B_S`: The basic minimum balance which all services require.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
  */
-const recent_blocks_MAX_RECENT_HISTORY = 8;
-/** Recent history of a single block. */
-class recent_blocks_BlockState extends WithDebug {
-    headerHash;
-    accumulationResult;
-    postStateRoot;
-    reported;
-    static Codec = descriptors_codec.Class(recent_blocks_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(refine_context_WorkPackageInfo.Codec, (x) => x.workPackageHash),
-    });
-    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
-        return new recent_blocks_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;
-    }
-}
+const service_BASE_SERVICE_BALANCE = 100n;
 /**
- * Recent history of blocks.
+ * `B_I`: The additional minimum balance required per item of elective service state.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
- */
-class recent_blocks_RecentBlocks extends WithDebug {
-    blocks;
-    accumulationLog;
-    static Codec = descriptors_codec.Class(recent_blocks_RecentBlocks, {
-        blocks: codecKnownSizeArray(recent_blocks_BlockState.Codec, {
-            minLength: 0,
-            maxLength: recent_blocks_MAX_RECENT_HISTORY,
-            typicalLength: recent_blocks_MAX_RECENT_HISTORY,
-        }),
-        accumulationLog: descriptors_codec.object({
-            peaks: readonlyArray(descriptors_codec.sequenceVarLen(descriptors_codec.optional(descriptors_codec.bytes(hash_HASH_SIZE)))),
-        }),
-    });
-    static empty() {
-        return new recent_blocks_RecentBlocks(sized_array_asKnownSize([]), {
-            peaks: [],
-        });
-    }
-    static create(a) {
-        return new recent_blocks_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) => hash_set_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_BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: descriptors_codec.bytes(ed25519_ED25519_KEY_BYTES).asOpaque(),
-        bls: descriptors_codec.bytes(bandersnatch_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 = codecPerValidator(validator_data_ValidatorData.Codec);
-
-;// CONCATENATED MODULE: ./packages/jam/state/safrole-data.ts
-
-
-
-
-
-
-
-
-
-
-
-var safrole_data_SafroleSealingKeysKind;
-(function (SafroleSealingKeysKind) {
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
-})(safrole_data_SafroleSealingKeysKind || (safrole_data_SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = descriptors_codec.bytes(bandersnatch_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 === safrole_data_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 === safrole_data_SafroleSealingKeysKind.Keys) {
-                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
-                return safrole_data_SafroleSealingKeysData.keys(common_tryAsPerEpochBlock(keys, context));
-            }
-            if (kind === safrole_data_SafroleSealingKeysKind.Tickets) {
-                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-                return safrole_data_SafroleSealingKeysData.tickets(common_tryAsPerEpochBlock(tickets, context));
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        }, (s) => {
-            const kind = s.decoder.varU32();
-            if (kind === safrole_data_SafroleSealingKeysKind.Keys) {
-                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-                return;
-            }
-            if (kind === safrole_data_SafroleSealingKeysKind.Tickets) {
-                s.sequenceFixLen(Ticket.Codec, context.epochLength);
-                return;
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        });
-    });
-    static keys(keys) {
-        return new safrole_data_SafroleSealingKeysData(safrole_data_SafroleSealingKeysKind.Keys, keys, undefined);
-    }
-    static tickets(tickets) {
-        return new safrole_data_SafroleSealingKeysData(safrole_data_SafroleSealingKeysKind.Tickets, undefined, tickets);
-    }
-    constructor(kind, keys, tickets) {
-        super();
-        this.kind = kind;
-        this.keys = keys;
-        this.tickets = tickets;
-    }
-}
-class safrole_data_SafroleData {
-    nextValidatorData;
-    epochRoot;
-    sealingKeySeries;
-    ticketsAccumulator;
-    static Codec = descriptors_codec.Class(safrole_data_SafroleData, {
-        nextValidatorData: codecPerValidator(validator_data_ValidatorData.Codec),
-        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
-        sealingKeySeries: safrole_data_SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
-    });
-    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
-        return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
-    }
-    constructor(
-    /** gamma_k */
-    nextValidatorData, 
-    /** gamma_z */
-    epochRoot, 
-    /** gamma_s */
-    sealingKeySeries, 
-    /** gamma_a */
-    ticketsAccumulator) {
-        this.nextValidatorData = nextValidatorData;
-        this.epochRoot = epochRoot;
-        this.sealingKeySeries = sealingKeySeries;
-        this.ticketsAccumulator = ticketsAccumulator;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/jam/state/service.ts
-
-
-
-
-
-
-/**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-const service_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
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
  */
 const service_ELECTIVE_ITEM_BALANCE = 10n;
 /**
@@ -12139,370 +11808,30 @@ class service_LookupHistoryItem {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/jam/state/statistics.ts
-
+;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
 
 
 
 
 
-const codecServiceId = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
-    ? descriptors_codec.u32.asOpaque()
-    : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => common_tryAsServiceId(i));
-/**
- * Activity Record of a single validator.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
- */
-class statistics_ValidatorStatistics {
-    blocks;
-    tickets;
-    preImages;
-    preImagesSize;
-    guarantees;
-    assurances;
-    static Codec = descriptors_codec.Class(statistics_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,
+/** Dictionary entry of services that auto-accumulate every block. */
+class privileged_services_AutoAccumulate {
+    service;
+    gasLimit;
+    static Codec = descriptors_codec.Class(privileged_services_AutoAccumulate, {
+        service: descriptors_codec.u32.asOpaque(),
+        gasLimit: descriptors_codec.u64.asOpaque(),
     });
-    static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
-        return new statistics_ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
+    static create({ service, gasLimit }) {
+        return new privileged_services_AutoAccumulate(service, gasLimit);
     }
     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 statistics_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) => common_tryAsServiceGas(i));
-/**
- * Single core statistics.
- * Updated per block, based on incoming work reports (`w`).
- *
- * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
- * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
- */
-class CoreStatistics {
-    dataAvailabilityLoad;
-    popularity;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    bundleSize;
-    gasUsed;
-    static Codec = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_0)
-        ? descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            extrinsicCount: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            exports: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
-            gasUsed: codecVarGas,
-        })
-        : descriptors_codec.Class(CoreStatistics, {
-            dataAvailabilityLoad: descriptors_codec.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            extrinsicCount: codecVarU16,
-            bundleSize: descriptors_codec.varU32,
-            gasUsed: codecVarGas,
-        });
-    static create(v) {
-        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
-    }
-    constructor(
-    /** `d` */
-    dataAvailabilityLoad, 
-    /** `p` */
-    popularity, 
-    /** `i` */
-    imports, 
-    /** `e` */
-    exports, 
-    /** `z` */
-    extrinsicSize, 
-    /** `x` */
-    extrinsicCount, 
-    /** `b` */
-    bundleSize, 
-    /** `u` */
-    gasUsed) {
-        this.dataAvailabilityLoad = dataAvailabilityLoad;
-        this.popularity = popularity;
-        this.imports = imports;
-        this.exports = exports;
-        this.extrinsicSize = extrinsicSize;
-        this.extrinsicCount = extrinsicCount;
-        this.bundleSize = bundleSize;
-        this.gasUsed = gasUsed;
-    }
-    static empty() {
-        const zero = numbers_tryAsU32(0);
-        const zero16 = numbers_tryAsU16(0);
-        const zeroGas = common_tryAsServiceGas(0);
-        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
-    }
-}
-/**
- * Service statistics.
- * Updated per block, based on available work reports (`W`).
- *
- * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
- */
-class statistics_ServiceStatistics {
-    providedCount;
-    providedSize;
-    refinementCount;
-    refinementGasUsed;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    accumulateCount;
-    accumulateGasUsed;
-    onTransfersCount;
-    onTransfersGasUsed;
-    static Codec = compatibility_Compatibility.selectIfGreaterOrEqual({
-        fallback: descriptors_codec.Class(statistics_ServiceStatistics, {
-            providedCount: codecVarU16,
-            providedSize: descriptors_codec.varU32,
-            refinementCount: descriptors_codec.varU32,
-            refinementGasUsed: codecVarGas,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: descriptors_codec.varU32,
-            extrinsicCount: codecVarU16,
-            accumulateCount: descriptors_codec.varU32,
-            accumulateGasUsed: codecVarGas,
-            onTransfersCount: descriptors_codec.varU32,
-            onTransfersGasUsed: codecVarGas,
-        }),
-        versions: {
-            [compatibility_GpVersion.V0_7_0]: descriptors_codec.Class(statistics_ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: descriptors_codec.varU32,
-                refinementCount: descriptors_codec.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: descriptors_codec.varU32,
-                exports: codecVarU16,
-                accumulateCount: descriptors_codec.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: descriptors_codec.varU32,
-                onTransfersGasUsed: codecVarGas,
-            }),
-            [compatibility_GpVersion.V0_7_1]: descriptors_codec.Class(statistics_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(common_tryAsServiceGas(0)),
-            }),
-        },
-    });
-    static create(v) {
-        return new statistics_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() {
-        const zero = numbers_tryAsU32(0);
-        const zero16 = numbers_tryAsU16(0);
-        const zeroGas = common_tryAsServiceGas(0);
-        return new statistics_ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
-    }
-}
-/** `pi`: Statistics of each validator, cores statistics and services statistics. */
-class statistics_StatisticsData {
-    current;
-    previous;
-    cores;
-    services;
-    static Codec = descriptors_codec.Class(statistics_StatisticsData, {
-        current: codecPerValidator(statistics_ValidatorStatistics.Codec),
-        previous: codecPerValidator(statistics_ValidatorStatistics.Codec),
-        cores: codecPerCore(CoreStatistics.Codec),
-        services: descriptors_codec.dictionary(codecServiceId, statistics_ServiceStatistics.Codec, {
-            sortKeys: (a, b) => a - b,
-        }),
-    });
-    static create(v) {
-        return new statistics_StatisticsData(v.current, v.previous, v.cores, v.services);
-    }
-    constructor(current, previous, cores, services) {
-        this.current = current;
-        this.previous = previous;
-        this.cores = cores;
-        this.services = services;
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/jam/state/in-memory-state-view.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(recent_blocks_RecentBlocks.Codec, this.state.recentBlocks, this.chainSpec);
-    }
-    statisticsView() {
-        return reencodeAsView(statistics_StatisticsData.Codec, this.state.statistics, this.chainSpec);
-    }
-    accumulationQueueView() {
-        return reencodeAsView(accumulationQueueCodec, this.state.accumulationQueue, this.chainSpec);
-    }
-    recentlyAccumulatedView() {
-        return reencodeAsView(recentlyAccumulatedCodec, this.state.recentlyAccumulated, this.chainSpec);
-    }
-    safroleDataView() {
-        // TODO [ToDr] Consider exposting `safrole` from state
-        // instead of individual fields
-        const safrole = safrole_data_SafroleData.create({
-            nextValidatorData: this.state.nextValidatorData,
-            epochRoot: this.state.epochRoot,
-            sealingKeySeries: this.state.sealingKeySeries,
-            ticketsAccumulator: this.state.ticketsAccumulator,
-        });
-        return reencodeAsView(safrole_data_SafroleData.Codec, safrole, this.chainSpec);
-    }
-    getServiceInfoView(id) {
-        const service = this.state.getService(id);
-        if (service === null) {
-            return null;
-        }
-        return reencodeAsView(service_ServiceAccountInfo.Codec, service.getInfo(), this.chainSpec);
-    }
-}
-
-;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
-
-
-
-
-
-/** Dictionary entry of services that auto-accumulate every block. */
-class privileged_services_AutoAccumulate {
-    service;
-    gasLimit;
-    static Codec = descriptors_codec.Class(privileged_services_AutoAccumulate, {
-        service: descriptors_codec.u32.asOpaque(),
-        gasLimit: descriptors_codec.u64.asOpaque(),
-    });
-    static create({ service, gasLimit }) {
-        return new privileged_services_AutoAccumulate(service, gasLimit);
-    }
-    constructor(
-    /** Service id that auto-accumulates. */
-    service, 
-    /** Gas limit for auto-accumulation. */
-    gasLimit) {
-        this.service = service;
-        this.gasLimit = gasLimit;
+    /** Service id that auto-accumulates. */
+    service, 
+    /** Gas limit for auto-accumulation. */
+    gasLimit) {
+        this.service = service;
+        this.gasLimit = gasLimit;
     }
 }
 /**
@@ -12554,6 +11883,286 @@ class privileged_services_PrivilegedServices {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
+
+
+
+
+
+
+/**
+ * `H = 8`: The size of recent history, in blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ */
+const recent_blocks_MAX_RECENT_HISTORY = 8;
+/** Recent history of a single block. */
+class recent_blocks_BlockState extends WithDebug {
+    headerHash;
+    accumulationResult;
+    postStateRoot;
+    reported;
+    static Codec = descriptors_codec.Class(recent_blocks_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(refine_context_WorkPackageInfo.Codec, (x) => x.workPackageHash),
+    });
+    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
+        return new recent_blocks_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;
+    }
+}
+class recent_blocks_RecentBlocks extends WithDebug {
+    blocks;
+    accumulationLog;
+    static Codec = descriptors_codec.Class(recent_blocks_RecentBlocks, {
+        blocks: codecKnownSizeArray(recent_blocks_BlockState.Codec, {
+            minLength: 0,
+            maxLength: recent_blocks_MAX_RECENT_HISTORY,
+            typicalLength: recent_blocks_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 recent_blocks_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;
+    }
+}
+/**
+ * Recent history of blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
+ */
+class recent_blocks_RecentBlocksHistory extends WithDebug {
+    current;
+    static Codec = Descriptor.new("RecentBlocksHistory", recent_blocks_RecentBlocks.Codec.sizeHint, (encoder, value) => recent_blocks_RecentBlocks.Codec.encode(encoder, value.asCurrent()), (decoder) => {
+        const recentBlocks = recent_blocks_RecentBlocks.Codec.decode(decoder);
+        return recent_blocks_RecentBlocksHistory.create(recentBlocks);
+    }, (skip) => {
+        return recent_blocks_RecentBlocks.Codec.skip(skip);
+    });
+    static create(recentBlocks) {
+        return new recent_blocks_RecentBlocksHistory(recentBlocks);
+    }
+    static empty() {
+        return recent_blocks_RecentBlocksHistory.create(recent_blocks_RecentBlocks.create({
+            blocks: sized_array_asKnownSize([]),
+            accumulationLog: { peaks: [] },
+        }));
+    }
+    /**
+     * Returns the block's BEEFY super peak.
+     */
+    static accumulationResult(block) {
+        return block.accumulationResult;
+    }
+    constructor(current) {
+        super();
+        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 recent_blocks_RecentBlocksHistory.create(recent_blocks_RecentBlocks.create({
+                ...this.current,
+                blocks: opaque_asOpaqueType(blocks),
+            }));
+        }
+        throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
+    }
+}
+
+;// 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_BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: descriptors_codec.bytes(ed25519_ED25519_KEY_BYTES).asOpaque(),
+        bls: descriptors_codec.bytes(bandersnatch_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;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/state/safrole-data.ts
+
+
+
+
+
+
+
+
+
+
+
+var safrole_data_SafroleSealingKeysKind;
+(function (SafroleSealingKeysKind) {
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
+})(safrole_data_SafroleSealingKeysKind || (safrole_data_SafroleSealingKeysKind = {}));
+const codecBandersnatchKey = descriptors_codec.bytes(bandersnatch_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 === safrole_data_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 === safrole_data_SafroleSealingKeysKind.Keys) {
+                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
+                return safrole_data_SafroleSealingKeysData.keys(common_tryAsPerEpochBlock(keys, context));
+            }
+            if (kind === safrole_data_SafroleSealingKeysKind.Tickets) {
+                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+                return safrole_data_SafroleSealingKeysData.tickets(common_tryAsPerEpochBlock(tickets, context));
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        }, (s) => {
+            const kind = s.decoder.varU32();
+            if (kind === safrole_data_SafroleSealingKeysKind.Keys) {
+                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
+                return;
+            }
+            if (kind === safrole_data_SafroleSealingKeysKind.Tickets) {
+                s.sequenceFixLen(Ticket.Codec, context.epochLength);
+                return;
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        });
+    });
+    static keys(keys) {
+        return new safrole_data_SafroleSealingKeysData(safrole_data_SafroleSealingKeysKind.Keys, keys, undefined);
+    }
+    static tickets(tickets) {
+        return new safrole_data_SafroleSealingKeysData(safrole_data_SafroleSealingKeysKind.Tickets, undefined, tickets);
+    }
+    constructor(kind, keys, tickets) {
+        super();
+        this.kind = kind;
+        this.keys = keys;
+        this.tickets = tickets;
+    }
+}
+class safrole_data_SafroleData {
+    nextValidatorData;
+    epochRoot;
+    sealingKeySeries;
+    ticketsAccumulator;
+    static Codec = descriptors_codec.Class(safrole_data_SafroleData, {
+        nextValidatorData: codecPerValidator(validator_data_ValidatorData.Codec),
+        epochRoot: descriptors_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        sealingKeySeries: safrole_data_SafroleSealingKeysData.Codec,
+        ticketsAccumulator: readonlyArray(descriptors_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+    });
+    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
+        return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
+    }
+    constructor(
+    /** gamma_k */
+    nextValidatorData, 
+    /** gamma_z */
+    epochRoot, 
+    /** gamma_s */
+    sealingKeySeries, 
+    /** gamma_a */
+    ticketsAccumulator) {
+        this.nextValidatorData = nextValidatorData;
+        this.epochRoot = epochRoot;
+        this.sealingKeySeries = sealingKeySeries;
+        this.ticketsAccumulator = ticketsAccumulator;
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/jam/state/state.ts
 /**
  * In addition to the entropy accumulator η_0, we retain
@@ -12661,57 +12270,329 @@ class state_update_UpdateService {
         this.serviceId = serviceId;
         this.action = action;
     }
-    static update({ serviceId, serviceInfo }) {
-        return new state_update_UpdateService(serviceId, {
-            kind: state_update_UpdateServiceKind.Update,
-            account: serviceInfo,
-        });
+    static update({ serviceId, serviceInfo }) {
+        return new state_update_UpdateService(serviceId, {
+            kind: state_update_UpdateServiceKind.Update,
+            account: serviceInfo,
+        });
+    }
+    static create({ serviceId, serviceInfo, lookupHistory, }) {
+        return new state_update_UpdateService(serviceId, {
+            kind: state_update_UpdateServiceKind.Create,
+            account: serviceInfo,
+            lookupHistory,
+        });
+    }
+}
+/** Update service storage kind. */
+var state_update_UpdateStorageKind;
+(function (UpdateStorageKind) {
+    /** Set a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
+    /** Remove a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
+})(state_update_UpdateStorageKind || (state_update_UpdateStorageKind = {}));
+/**
+ * Update service storage item.
+ *
+ * Can either create/modify an entry or remove it.
+ */
+class state_update_UpdateStorage {
+    serviceId;
+    action;
+    constructor(serviceId, action) {
+        this.serviceId = serviceId;
+        this.action = action;
+    }
+    static set({ serviceId, storage }) {
+        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Set, storage });
+    }
+    static remove({ serviceId, key }) {
+        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Remove, key });
+    }
+    get key() {
+        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
+            return this.action.key;
+        }
+        return this.action.storage.key;
+    }
+    get value() {
+        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
+            return null;
+        }
+        return this.action.storage.value;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/state/statistics.ts
+
+
+
+
+
+
+const codecServiceId = compatibility_Compatibility.isSuite(TestSuite.W3F_DAVXY) || compatibility_Compatibility.isSuite(TestSuite.JAMDUNA, compatibility_GpVersion.V0_6_7)
+    ? descriptors_codec.u32.asOpaque()
+    : descriptors_codec.varU32.convert((s) => numbers_tryAsU32(s), (i) => common_tryAsServiceId(i));
+/**
+ * Activity Record of a single validator.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
+ */
+class statistics_ValidatorStatistics {
+    blocks;
+    tickets;
+    preImages;
+    preImagesSize;
+    guarantees;
+    assurances;
+    static Codec = descriptors_codec.Class(statistics_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 statistics_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 statistics_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) => common_tryAsServiceGas(i));
+/**
+ * Single core statistics.
+ * Updated per block, based on incoming work reports (`w`).
+ *
+ * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
+ * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
+ */
+class CoreStatistics {
+    dataAvailabilityLoad;
+    popularity;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    bundleSize;
+    gasUsed;
+    static Codec = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_0)
+        ? descriptors_codec.Class(CoreStatistics, {
+            dataAvailabilityLoad: descriptors_codec.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            extrinsicCount: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            exports: codecVarU16,
+            bundleSize: descriptors_codec.varU32,
+            gasUsed: codecVarGas,
+        })
+        : descriptors_codec.Class(CoreStatistics, {
+            dataAvailabilityLoad: descriptors_codec.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            extrinsicCount: codecVarU16,
+            bundleSize: descriptors_codec.varU32,
+            gasUsed: codecVarGas,
+        });
+    static create(v) {
+        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
+    }
+    constructor(
+    /** `d` */
+    dataAvailabilityLoad, 
+    /** `p` */
+    popularity, 
+    /** `i` */
+    imports, 
+    /** `e` */
+    exports, 
+    /** `z` */
+    extrinsicSize, 
+    /** `x` */
+    extrinsicCount, 
+    /** `b` */
+    bundleSize, 
+    /** `u` */
+    gasUsed) {
+        this.dataAvailabilityLoad = dataAvailabilityLoad;
+        this.popularity = popularity;
+        this.imports = imports;
+        this.exports = exports;
+        this.extrinsicSize = extrinsicSize;
+        this.extrinsicCount = extrinsicCount;
+        this.bundleSize = bundleSize;
+        this.gasUsed = gasUsed;
+    }
+    static empty() {
+        const zero = numbers_tryAsU32(0);
+        const zero16 = numbers_tryAsU16(0);
+        const zeroGas = common_tryAsServiceGas(0);
+        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
+    }
+}
+/**
+ * Service statistics.
+ * Updated per block, based on available work reports (`W`).
+ *
+ * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
+ */
+class statistics_ServiceStatistics {
+    providedCount;
+    providedSize;
+    refinementCount;
+    refinementGasUsed;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    accumulateCount;
+    accumulateGasUsed;
+    onTransfersCount;
+    onTransfersGasUsed;
+    static Codec = compatibility_Compatibility.selectIfGreaterOrEqual({
+        fallback: descriptors_codec.Class(statistics_ServiceStatistics, {
+            providedCount: codecVarU16,
+            providedSize: descriptors_codec.varU32,
+            refinementCount: descriptors_codec.varU32,
+            refinementGasUsed: codecVarGas,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: descriptors_codec.varU32,
+            extrinsicCount: codecVarU16,
+            accumulateCount: descriptors_codec.varU32,
+            accumulateGasUsed: codecVarGas,
+            onTransfersCount: descriptors_codec.varU32,
+            onTransfersGasUsed: codecVarGas,
+        }),
+        versions: {
+            [compatibility_GpVersion.V0_7_0]: descriptors_codec.Class(statistics_ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: descriptors_codec.varU32,
+                refinementCount: descriptors_codec.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: descriptors_codec.varU32,
+                exports: codecVarU16,
+                accumulateCount: descriptors_codec.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: descriptors_codec.varU32,
+                onTransfersGasUsed: codecVarGas,
+            }),
+            [compatibility_GpVersion.V0_7_1]: descriptors_codec.Class(statistics_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(common_tryAsServiceGas(0)),
+            }),
+        },
+    });
+    static create(v) {
+        return new statistics_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 create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new state_update_UpdateService(serviceId, {
-            kind: state_update_UpdateServiceKind.Create,
-            account: serviceInfo,
-            lookupHistory,
-        });
+    static empty() {
+        const zero = numbers_tryAsU32(0);
+        const zero16 = numbers_tryAsU16(0);
+        const zeroGas = common_tryAsServiceGas(0);
+        return new statistics_ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
     }
 }
-/** Update service storage kind. */
-var state_update_UpdateStorageKind;
-(function (UpdateStorageKind) {
-    /** Set a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
-    /** Remove a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
-})(state_update_UpdateStorageKind || (state_update_UpdateStorageKind = {}));
-/**
- * Update service storage item.
- *
- * Can either create/modify an entry or remove it.
- */
-class state_update_UpdateStorage {
-    serviceId;
-    action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
-        this.action = action;
-    }
-    static set({ serviceId, storage }) {
-        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Set, storage });
-    }
-    static remove({ serviceId, key }) {
-        return new state_update_UpdateStorage(serviceId, { kind: state_update_UpdateStorageKind.Remove, key });
-    }
-    get key() {
-        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
-            return this.action.key;
-        }
-        return this.action.storage.key;
+/** `pi`: Statistics of each validator, cores statistics and services statistics. */
+class statistics_StatisticsData {
+    current;
+    previous;
+    cores;
+    services;
+    static Codec = descriptors_codec.Class(statistics_StatisticsData, {
+        current: codecPerValidator(statistics_ValidatorStatistics.Codec),
+        previous: codecPerValidator(statistics_ValidatorStatistics.Codec),
+        cores: codecPerCore(CoreStatistics.Codec),
+        services: descriptors_codec.dictionary(codecServiceId, statistics_ServiceStatistics.Codec, {
+            sortKeys: (a, b) => a - b,
+        }),
+    });
+    static create(v) {
+        return new statistics_StatisticsData(v.current, v.previous, v.cores, v.services);
     }
-    get value() {
-        if (this.action.kind === state_update_UpdateStorageKind.Remove) {
-            return null;
-        }
-        return this.action.storage.value;
+    constructor(current, previous, cores, services) {
+        this.current = current;
+        this.previous = previous;
+        this.cores = cores;
+        this.services = services;
     }
 }
 
@@ -12736,7 +12617,6 @@ class state_update_UpdateStorage {
 
 
 
-
 
 
 var in_memory_state_UpdateError;
@@ -12838,10 +12718,9 @@ class InMemoryService extends WithDebug {
  * A special version of state, stored fully in-memory.
  */
 class InMemoryState extends WithDebug {
-    chainSpec;
     /** Create a new `InMemoryState` by providing all required fields. */
-    static new(chainSpec, state) {
-        return new InMemoryState(chainSpec, state);
+    static create(state) {
+        return new InMemoryState(state);
     }
     /**
      * Create a new `InMemoryState` with a partial state override.
@@ -12857,7 +12736,7 @@ class InMemoryState extends WithDebug {
     /**
      * Create a new `InMemoryState` from some other state object.
      */
-    static copyFrom(chainSpec, other, servicesData) {
+    static copyFrom(other, servicesData) {
         const services = new Map();
         for (const [id, entries] of servicesData.entries()) {
             const service = other.getService(id);
@@ -12867,7 +12746,7 @@ class InMemoryState extends WithDebug {
             const inMemService = InMemoryService.copyFrom(service, entries);
             services.set(id, inMemService);
         }
-        return InMemoryState.new(chainSpec, {
+        return InMemoryState.create({
             availabilityAssignment: other.availabilityAssignment,
             accumulationQueue: other.accumulationQueue,
             designatedValidatorData: other.designatedValidatorData,
@@ -13064,9 +12943,8 @@ class InMemoryState extends WithDebug {
     getService(id) {
         return this.services.get(id) ?? null;
     }
-    constructor(chainSpec, s) {
+    constructor(s) {
         super();
-        this.chainSpec = chainSpec;
         this.availabilityAssignment = s.availabilityAssignment;
         this.designatedValidatorData = s.designatedValidatorData;
         this.nextValidatorData = s.nextValidatorData;
@@ -13088,14 +12966,11 @@ 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(spec, {
+        return new InMemoryState({
             availabilityAssignment: common_tryAsPerCore(Array.from({ length: spec.coresCount }, () => null), spec),
             designatedValidatorData: common_tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => validator_data_ValidatorData.create({
                 bandersnatch: bytes_Bytes.zero(bandersnatch_BANDERSNATCH_KEY_BYTES).asOpaque(),
@@ -13130,8 +13005,8 @@ class InMemoryState extends WithDebug {
             timeslot: common_tryAsTimeSlot(0),
             entropy: sized_array_FixedSizeArray.fill(() => bytes_Bytes.zero(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
             authPools: common_tryAsPerCore(Array.from({ length: spec.coresCount }, () => sized_array_asKnownSize([])), spec),
-            authQueues: common_tryAsPerCore(Array.from({ length: spec.coresCount }, () => sized_array_FixedSizeArray.fill(() => bytes_Bytes.zero(hash_HASH_SIZE).asOpaque(), auth_AUTHORIZATION_QUEUE_SIZE)), spec),
-            recentBlocks: recent_blocks_RecentBlocks.empty(),
+            authQueues: common_tryAsPerCore(Array.from({ length: spec.coresCount }, () => sized_array_FixedSizeArray.fill(() => bytes_Bytes.zero(hash_HASH_SIZE).asOpaque(), gp_constants_AUTHORIZATION_QUEUE_SIZE)), spec),
+            recentBlocks: recent_blocks_RecentBlocksHistory.empty(),
             statistics: statistics_StatisticsData.create({
                 current: common_tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => statistics_ValidatorStatistics.empty()), spec),
                 previous: common_tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => statistics_ValidatorStatistics.empty()), spec),
@@ -13182,10 +13057,6 @@ const serviceDataCodec = descriptors_codec.dictionary(descriptors_codec.u32.asOp
 
 
 
-
-
-
-
 ;// CONCATENATED MODULE: ./packages/jam/state-json/accounts.ts
 
 
@@ -13357,6 +13228,51 @@ const accumulationOutput = json.object({
     output: fromJson.bytes32(),
 }, ({ serviceId, output }) => AccumulationOutput.create({ serviceId, output }));
 
+;// 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 not_yet_accumulated_NotYetAccumulatedReport extends WithDebug {
+    report;
+    dependencies;
+    static Codec = descriptors_codec.Class(not_yet_accumulated_NotYetAccumulatedReport, {
+        report: work_report_WorkReport.Codec,
+        dependencies: codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+            typicalLength: gp_constants_MAX_REPORT_DEPENDENCIES / 2,
+            maxLength: gp_constants_MAX_REPORT_DEPENDENCIES,
+            minLength: 0,
+        }),
+    });
+    static create({ report, dependencies }) {
+        return new not_yet_accumulated_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-json/not-yet-accumulated.ts
 
 
@@ -13364,7 +13280,7 @@ const accumulationOutput = json.object({
 const notYetAccumulatedFromJson = json.object({
     report: workReportFromJson,
     dependencies: json.array(fromJson.bytes32()),
-}, ({ report, dependencies }) => accumulation_queue_NotYetAccumulatedReport.create({ report, dependencies }));
+}, ({ report, dependencies }) => not_yet_accumulated_NotYetAccumulatedReport.create({ report, dependencies }));
 
 ;// CONCATENATED MODULE: ./packages/jam/state-json/recent-history.ts
 
@@ -13397,10 +13313,10 @@ const recentBlocksHistoryFromJson = json.object({
         peaks: json.array(json.nullable(fromJson.bytes32())),
     },
 }, ({ history, mmr }) => {
-    return recent_blocks_RecentBlocks.create({
+    return recent_blocks_RecentBlocksHistory.create(recent_blocks_RecentBlocks.create({
         blocks: history,
         accumulationLog: mmr,
-    });
+    }));
 });
 
 ;// CONCATENATED MODULE: ./packages/jam/state-json/safrole.ts
@@ -13598,6 +13514,7 @@ const validatorDataFromJson = json.object({
 
 
 
+
 const fullStateDumpFromJson = (spec) => json.object({
     alpha: json.array(json.array(fromJson.bytes32())),
     varphi: json.array(json.array(fromJson.bytes32())),
@@ -13634,20 +13551,20 @@ const fullStateDumpFromJson = (spec) => json.object({
     if (compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1) && chi.chi_r === undefined) {
         throw new Error("Registrar is required in Privileges GP ^0.7.1");
     }
-    return InMemoryState.new(spec, {
+    return InMemoryState.create({
         authPools: common_tryAsPerCore(alpha.map((perCore) => {
-            if (perCore.length > auth_MAX_AUTH_POOL_SIZE) {
-                throw new Error(`AuthPools: expected less than ${auth_MAX_AUTH_POOL_SIZE}, got ${perCore.length}`);
+            if (perCore.length > gp_constants_MAX_AUTH_POOL_SIZE) {
+                throw new Error(`AuthPools: expected less than ${gp_constants_MAX_AUTH_POOL_SIZE}, got ${perCore.length}`);
             }
             return sized_array_asKnownSize(perCore);
         }), spec),
         authQueues: common_tryAsPerCore(varphi.map((perCore) => {
-            if (perCore.length !== auth_AUTHORIZATION_QUEUE_SIZE) {
-                throw new Error(`AuthQueues: expected ${auth_AUTHORIZATION_QUEUE_SIZE}, got: ${perCore.length}`);
+            if (perCore.length !== gp_constants_AUTHORIZATION_QUEUE_SIZE) {
+                throw new Error(`AuthQueues: expected ${gp_constants_AUTHORIZATION_QUEUE_SIZE}, got: ${perCore.length}`);
             }
             return sized_array_asKnownSize(perCore);
         }), spec),
-        recentBlocks: beta ?? recent_blocks_RecentBlocks.empty(),
+        recentBlocks: beta ?? recent_blocks_RecentBlocksHistory.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -13861,19 +13778,26 @@ function legacyServiceNested(serviceId, hash) {
 
 
 
+
+
+
 /** Serialization for particular state entries. */
 var serialize_serialize;
 (function (serialize) {
     /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
     serialize.authPools = {
         key: stateKeys.index(StateKeyIdx.Alpha),
-        Codec: authPoolsCodec,
+        Codec: codecPerCore(codecKnownSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+            minLength: 0,
+            maxLength: gp_constants_MAX_AUTH_POOL_SIZE,
+            typicalLength: gp_constants_MAX_AUTH_POOL_SIZE,
+        })),
         extract: (s) => s.authPools,
     };
     /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
     serialize.authQueues = {
         key: stateKeys.index(StateKeyIdx.Phi),
-        Codec: authQueuesCodec,
+        Codec: codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), gp_constants_AUTHORIZATION_QUEUE_SIZE)),
         extract: (s) => s.authQueues,
     };
     /**
@@ -13882,7 +13806,7 @@ var serialize_serialize;
      */
     serialize.recentBlocks = {
         key: stateKeys.index(StateKeyIdx.Beta),
-        Codec: recent_blocks_RecentBlocks.Codec,
+        Codec: recent_blocks_RecentBlocksHistory.Codec,
         extract: (s) => s.recentBlocks,
     };
     /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
@@ -13911,25 +13835,25 @@ var serialize_serialize;
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
     serialize.designatedValidators = {
         key: stateKeys.index(StateKeyIdx.Iota),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
         extract: (s) => s.designatedValidatorData,
     };
     /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
     serialize.currentValidators = {
         key: stateKeys.index(StateKeyIdx.Kappa),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
         extract: (s) => s.currentValidatorData,
     };
     /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
     serialize.previousValidators = {
         key: stateKeys.index(StateKeyIdx.Lambda),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
         extract: (s) => s.previousValidatorData,
     };
     /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
     serialize.availabilityAssignment = {
         key: stateKeys.index(StateKeyIdx.Rho),
-        Codec: availabilityAssignmentsCodec,
+        Codec: codecPerCore(descriptors_codec.optional(assurances_AvailabilityAssignment.Codec)),
         extract: (s) => s.availabilityAssignment,
     };
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
@@ -13953,13 +13877,13 @@ var serialize_serialize;
     /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
     serialize.accumulationQueue = {
         key: stateKeys.index(StateKeyIdx.Omega),
-        Codec: accumulationQueueCodec,
+        Codec: codecPerEpochBlock(readonlyArray(descriptors_codec.sequenceVarLen(not_yet_accumulated_NotYetAccumulatedReport.Codec))),
         extract: (s) => s.accumulationQueue,
     };
     /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
     serialize.recentlyAccumulated = {
         key: stateKeys.index(StateKeyIdx.Xi),
-        Codec: recentlyAccumulatedCodec,
+        Codec: codecPerEpochBlock(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => hash_set_HashSet.from(x))),
         extract: (s) => s.recentlyAccumulated,
     };
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
@@ -13978,12 +13902,12 @@ var serialize_serialize;
     /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
     serialize.serviceStorage = (blake2b, serviceId, key) => ({
         key: stateKeys.serviceStorage(blake2b, serviceId, key),
-        Codec: dumpCodec,
+        Codec: serialize_dumpCodec,
     });
     /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
     serialize.servicePreimages = (blake2b, serviceId, hash) => ({
         key: stateKeys.servicePreimage(blake2b, serviceId, hash),
-        Codec: dumpCodec,
+        Codec: serialize_dumpCodec,
     });
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
@@ -13998,88 +13922,7 @@ var serialize_serialize;
  * determine the boundary of the bytes, so it can only be used
  * as the last element of the codec and can't be used in sequences!
  */
-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);
-    }
-}
+const serialize_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.ts
 
@@ -14089,8 +13932,6 @@ class SerializedStateView {
 
 
 
-
-
 /**
  * State object which reads it's entries from some backend.
  *
@@ -14103,7 +13944,7 @@ class serialized_state_SerializedState {
     spec;
     blake2b;
     backend;
-    recentlyUsedServices;
+    _recentServiceIds;
     /** 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);
@@ -14112,63 +13953,49 @@ 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. */
-    recentlyUsedServices) {
+    _recentServiceIds) {
         this.spec = spec;
         this.blake2b = blake2b;
         this.backend = backend;
-        this.recentlyUsedServices = recentlyUsedServices;
+        this._recentServiceIds = _recentServiceIds;
     }
     /** 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.recentlyUsedServices;
+        return this._recentServiceIds;
     }
     getService(id) {
         const serviceData = this.retrieveOptional(serialize_serialize.serviceData(id));
         if (serviceData === undefined) {
             return null;
         }
-        if (!this.recentlyUsedServices.includes(id)) {
-            this.recentlyUsedServices.push(id);
+        if (!this._recentServiceIds.includes(id)) {
+            this._recentServiceIds.push(id);
         }
         return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(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}`);
+    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}`);
         }
-        return data;
+        return decoder_Decoder.decodeObject(Codec, bytes, this.spec);
     }
     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;
         }
-        const data = decoder_Decoder.decodeObject(Codec, bytes, this.spec);
-        this.dataCache.set(key, data);
-        return data;
+        return decoder_Decoder.decodeObject(Codec, bytes, this.spec);
     }
     get availabilityAssignment() {
         return this.retrieve(serialize_serialize.availabilityAssignment, "availabilityAssignment");
@@ -15283,7 +15110,6 @@ function loader_loadState(spec, blake2b, entries) {
 
 
 
-
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/in-memory-state-codec.ts
 
 
@@ -15388,11 +15214,7 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const in_memory_state_codec_inMemoryStateCodec = (spec) => descriptors_codec.Class(class State extends InMemoryState {
-    static create(data) {
-        return InMemoryState.new(spec, data);
-    }
-}, {
+const in_memory_state_codec_inMemoryStateCodec = descriptors_codec.Class(InMemoryState, {
     // alpha
     authPools: serialize_serialize.authPools.Codec,
     // phi
@@ -15628,7 +15450,7 @@ class InMemoryStates {
     }
     /** Insert a full state into the database. */
     async insertState(headerHash, state) {
-        const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
+        const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
         this.db.set(headerHash, encoded);
         return Result.ok(OK);
     }
@@ -15637,7 +15459,7 @@ class InMemoryStates {
         if (encodedState === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+        return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
     }
 }
 
@@ -15680,21 +15502,21 @@ class hasher_TransitionHasher {
      */
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-        const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
-        const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
-        const guaranteesBlobs = extrinsicView.guarantees
+        const guarantees = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
-            .reduce((aggregated, guarantee) => {
+            .map((guarantee) => {
             const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque();
-            aggregated.push(reportHash.raw);
-            aggregated.push(guarantee.slot.encoded().raw);
-            aggregated.push(guarantee.credentials.encoded().raw);
-            return aggregated;
-        }, [countEncoded.raw]);
+            return BytesBlob.blobFromParts([
+                reportHash.raw,
+                guarantee.slot.encoded().raw,
+                guarantee.credentials.encoded().raw,
+            ]);
+        });
+        const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
         const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque();
         const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque();
-        const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque();
+        const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque();
         const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
         const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
         const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
@@ -16817,46 +16639,47 @@ class safrole_seal_SafroleSeal {
     }
     async verifySeal(headerView, state) {
         // we use transitioned keys already
+        const validators = state.currentValidatorData;
         const validatorIndex = headerView.bandersnatchBlockAuthorIndex.materialize();
-        const authorKeys = state.currentValidatorData.at(validatorIndex);
-        if (authorKeys === undefined) {
+        const authorKey = validators[validatorIndex];
+        if (authorKey === undefined) {
             return 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, authorKeys, headerView);
+            return await this.verifySealWithTicket(sealingKeys.tickets, timeSlot, entropy, validators, validatorIndex, headerView);
         }
-        return await this.verifySealWithKeys(sealingKeys.keys, timeSlot, entropy, authorKeys, headerView);
+        return await this.verifySealWithKeys(sealingKeys.keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView);
     }
     /** Regular (non-fallback) mode of Safrole. */
-    async verifySealWithTicket(tickets, timeSlot, entropy, validatorData, headerView) {
+    async verifySealWithTicket(tickets, timeSlot, entropy, validators, validatorIndex, headerView) {
         const index = timeSlot % tickets.length;
-        const ticket = tickets.at(index);
-        const payload = BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([ticket?.attempt ?? 0]));
+        const { id, attempt } = tickets[index];
+        const payload = BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt]));
         // verify seal correctness
-        const authorKey = validatorData.bandersnatch;
+        const authorKey = validators.at(validatorIndex)?.bandersnatch;
         const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, authorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return Result.error(SafroleSealError.IncorrectSeal);
         }
-        if (ticket === undefined || !ticket.id.isEqualTo(result.ok)) {
+        if (!id.isEqualTo(result.ok)) {
             return Result.error(SafroleSealError.InvalidTicket);
         }
         return Result.ok(result.ok);
     }
     /** Fallback mode of Safrole. */
-    async verifySealWithKeys(keys, timeSlot, entropy, authorKey, headerView) {
+    async verifySealWithKeys(keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView) {
         const index = timeSlot % keys.length;
-        const sealingKey = keys.at(index);
-        const authorBandersnatchKey = authorKey.bandersnatch;
-        if (sealingKey === undefined || !sealingKey.isEqualTo(authorBandersnatchKey)) {
+        const sealingKey = keys[index];
+        if (!sealingKey.isEqualTo(authorKey.bandersnatch)) {
             return Result.error(SafroleSealError.InvalidValidator, `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
         }
         // verify seal correctness
         const payload = BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw);
-        const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, authorBandersnatchKey, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
+        const blockAuthorKey = validators.at(validatorIndex)?.bandersnatch;
+        const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, blockAuthorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return Result.error(SafroleSealError.IncorrectSeal);
         }
@@ -22735,7 +22558,7 @@ class Assign {
         const authorizationQueueStart = regs.get(8);
         // a
         const assigners = getServiceId(regs.get(9));
-        const res = safe_alloc_uint8array_safeAllocUint8Array(hash_HASH_SIZE * auth_AUTHORIZATION_QUEUE_SIZE);
+        const res = safe_alloc_uint8array_safeAllocUint8Array(hash_HASH_SIZE * gp_constants_AUTHORIZATION_QUEUE_SIZE);
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
@@ -22749,8 +22572,8 @@ class Assign {
         // NOTE: Here we know the core index is valid
         const coreIndex = common_tryAsCoreIndex(Number(maybeCoreIndex));
         const decoder = decoder_Decoder.fromBlob(res);
-        const authQueue = decoder.sequenceFixLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), auth_AUTHORIZATION_QUEUE_SIZE);
-        const fixedSizeAuthQueue = sized_array_FixedSizeArray.new(authQueue, auth_AUTHORIZATION_QUEUE_SIZE);
+        const authQueue = decoder.sequenceFixLen(descriptors_codec.bytes(hash_HASH_SIZE), gp_constants_AUTHORIZATION_QUEUE_SIZE);
+        const fixedSizeAuthQueue = sized_array_FixedSizeArray.new(authQueue, gp_constants_AUTHORIZATION_QUEUE_SIZE);
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
             regs.set(IN_OUT_REG, results_HostCallResult.OK);
@@ -24496,10 +24319,9 @@ class accumulate_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 - timeslot) {
+            if (i < slot - this.state.timeslot) {
                 accumulationQueue[queueIndex] = [];
             }
             else {
@@ -24711,6 +24533,7 @@ class deferred_transfers_DeferredTransfers {
 
 
 
+
 /**
  * Maintain a list of available authorizations per core.
  *
@@ -24739,12 +24562,11 @@ class authorization_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 = authQueues[coreIndex];
+            const queue = this.state.authQueues[coreIndex];
             // if there were any used hashes - remove them
             const usedHashes = input.used.get(coreIndex);
             if (usedHashes !== undefined) {
@@ -24918,18 +24740,14 @@ class recent_history_RecentHistory {
      * https://graypaper.fluffylabs.dev/#/1c979cb/0f55020f5502?v=0.7.1
      */
     partialTransition(input) {
-        const stateBlocks = this.state.recentBlocks;
-        const recentBlocks = stateBlocks.blocks.slice();
+        const recentBlocks = this.state.recentBlocks.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: RecentBlocks.create({
-                blocks: asKnownSize(recentBlocks),
-                accumulationLog: stateBlocks.accumulationLog,
-            }), // β_H†
+            recentBlocks: this.state.recentBlocks.updateBlocks(recentBlocks), // β_H†
         };
     }
     /**
@@ -24941,8 +24759,8 @@ class recent_history_RecentHistory {
     transition(input) {
         const recentBlocks = input.partial.recentBlocks.blocks.slice();
         // `β′_B`
-        const mmr = this.state.recentBlocks.accumulationLog !== null
-            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.accumulationLog)
+        const mmr = this.state.recentBlocks.asCurrent().accumulationLog !== null
+            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.asCurrent().accumulationLog)
             : MerkleMountainRange.empty(this.hasher);
         // append the accumulation root
         mmr.append(input.accumulateRoot);
@@ -24960,7 +24778,7 @@ class recent_history_RecentHistory {
         }
         // write back to the state.
         return {
-            recentBlocks: RecentBlocks.create(RecentBlocks.create({
+            recentBlocks: RecentBlocksHistory.create(RecentBlocks.create({
                 blocks: asKnownSize(recentBlocks),
                 accumulationLog: peaks,
             })),
@@ -25172,6 +24990,7 @@ function verify_basic_verifyReportsBasic(input) {
 
 
 
+
 const verify_contextual_logger = Logger.new(import.meta.filename, "stf:reports");
 /** https://graypaper.fluffylabs.dev/#/7e6ff6a/15eb0115eb01?v=0.6.7 */
 function verify_contextual_verifyContextualValidity(input, state, headerChain, maxLookupAnchorAge) {
@@ -25284,7 +25103,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
             return Result.error(ReportsError.BadStateRoot, `Anchor state root mismatch. Got: ${context.stateRoot}, expected: ${recentBlock.postStateRoot}.`);
         }
         // check beefy root
-        const beefyRoot = recentBlock.accumulationResult;
+        const beefyRoot = RecentBlocksHistory.accumulationResult(recentBlock);
         if (!beefyRoot.isEqualTo(context.beefyRoot)) {
             return Result.error(ReportsError.BadBeefyMmrRoot, `Invalid BEEFY super peak hash. Got: ${context.beefyRoot}, expected: ${beefyRoot}. Anchor: ${recentBlock.headerHash}`);
         }
@@ -25526,9 +25345,8 @@ function verify_post_signature_verifyPostSignatureChecks(input, availabilityAssi
          * https://graypaper.fluffylabs.dev/#/5f542d7/15eb0015ed00
          */
         const authorizerHash = report.authorizerHash;
-        const authorizerPool = authPools.get(coreIndex);
-        const pool = authorizerPool?.materialize() ?? [];
-        if (pool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
+        const authorizerPool = authPools[coreIndex];
+        if (authorizerPool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
             return Result.error(ReportsError.CoreUnauthorized, `Authorizer hash not found in the pool of core ${coreIndex}: ${authorizerHash}`);
         }
         /**
@@ -25658,8 +25476,7 @@ class reports_Reports {
         return verifyCredentials(input.guarantees, workReportHashes, input.slot, (headerTimeSlot, guaranteeTimeSlot) => this.getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, input.newEntropy));
     }
     verifyPostSignatureChecks(input, assurancesAvailAssignment) {
-        const authPoolsView = this.state.view().authPoolsView();
-        return verifyPostSignatureChecks(input, assurancesAvailAssignment, authPoolsView, (id) => this.state.getService(id));
+        return verifyPostSignatureChecks(input, assurancesAvailAssignment, this.state.authPools, (id) => this.state.getService(id));
     }
     verifyContextualValidity(input) {
         return verifyContextualValidity(input, this.state, this.headerChain, this.chainSpec.maxLookupAnchorAge);
@@ -27221,20 +27038,18 @@ function dumpOutput(spec, data, type, outputFormat, args, withRelPath) {
             if (type.encode === undefined) {
                 throw new Error(`${type.name} does not support encoding to JAM codec.`);
             }
-            const encoder = typeof type.encode === "function" ? type.encode(spec) : type.encode;
-            const encoded = encoder_Encoder.encodeObject(encoder, data, spec);
+            const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
             dump(`${encoded}`);
             return;
         }
         case OutputFormat.Bin: {
-            if (destination === null) {
-                throw new Error(`${OutputFormat.Bin} requires destination file.`);
-            }
             if (type.encode === undefined) {
                 throw new Error(`${type.name} does not support encoding to JAM codec.`);
             }
-            const encoder = typeof type.encode === "function" ? type.encode(spec) : type.encode;
-            const encoded = encoder_Encoder.encodeObject(encoder, data, spec);
+            if (destination === null) {
+                throw new Error(`${OutputFormat.Bin} requires destination file.`);
+            }
+            const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
             dump(encoded.raw);
             return;
         }
@@ -27341,8 +27156,7 @@ async function loadAndProcessDataFile(file, withRelPath, flavor, decodeType, pro
         if (decodeType.decode === undefined) {
             throw new Error(`${decodeType.name} does not support decoding from binary data.`);
         }
-        const decoder = typeof decodeType.decode === "function" ? decodeType.decode(spec) : decodeType.decode;
-        data = decoder_Decoder.decodeObject(decoder, input.data, spec);
+        data = decoder_Decoder.decodeObject(decodeType.decode, input.data, spec);
     }
     else if (input.type === "json") {
         if (decodeType.json === undefined) {