@typeberry/convert 0.2.0-b6e3410 → 0.2.0-e767e74

package/index.js

@@ -6319,6 +6319,9 @@ class ObjectView {
     toString() {
         return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
     }
+    [TEST_COMPARE_USING]() {
+        return this.materialize();
+    }
 }
 /**
  * A lazy-evaluated decoder of a sequence.
@@ -6613,7 +6616,15 @@ var descriptors_codec;
     /** Custom encoding / decoding logic. */
     codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
     /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), chooser(null).View);
+    codec.select = ({ name, sizeHint, }, chooser) => {
+        const Self = chooser(null);
+        return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
+            ? codec.select({
+                name: Self.View.name,
+                sizeHint: Self.View.sizeHint,
+            }, (ctx) => chooser(ctx).View)
+            : Self.View);
+    };
     /**
      * A descriptor for a more complex POJO.
      *
@@ -10052,6 +10063,19 @@ 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
 
 
@@ -10070,6 +10094,7 @@ function block_emptyBlock(slot = tryAsTimeSlot(0)) {
 
 
 
+
 ;// 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. */
@@ -11438,10 +11463,128 @@ 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.
  *
@@ -11470,21 +11613,24 @@ 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
 
 
-/** 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 });
-});
+
+
+/** `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));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/disputes.ts
 
@@ -11552,65 +11698,6 @@ 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));
@@ -11618,7 +11705,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/service.ts
+;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
 
 
 
@@ -11626,30 +11713,274 @@ const math_consts_MAX_SHIFT_U64 = 64n;
 
 
 /**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-const service_BASE_SERVICE_BALANCE = 100n;
-/**
- * `B_I`: The additional minimum balance required per item of elective service state.
+ * `H = 8`: The size of recent history, in blocks.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
  */
-const service_ELECTIVE_ITEM_BALANCE = 10n;
+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;
+    }
+}
 /**
- * `B_L`: The additional minimum balance required per octet of elective service state.
+ * Recent history of blocks.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
  */
-const service_ELECTIVE_BYTE_BALANCE = 1n;
-const zeroSizeHint = {
-    bytes: 0,
-    isExact: true,
-};
-/** 0-byte read, return given default value */
-const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
-/** Encode and decode object with leading version number. */
+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
+ */
+const service_ELECTIVE_ITEM_BALANCE = 10n;
+/**
+ * `B_L`: The additional minimum balance required per octet of elective service state.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
+ */
+const service_ELECTIVE_BYTE_BALANCE = 1n;
+const zeroSizeHint = {
+    bytes: 0,
+    isExact: true,
+};
+/** 0-byte read, return given default value */
+const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
+/** Encode and decode object with leading version number. */
 const codecWithVersion = (val) => Descriptor.new("withVersion", {
     bytes: val.sizeHint.bytes + 8,
     isExact: false,
@@ -11802,525 +12133,9 @@ class service_LookupHistoryItem {
     }
     static isRequested(item) {
         if ("slots" in item) {
-            return item.slots.length === 0;
-        }
-        return item.length === 0;
-    }
-}
-
-;// 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;
-    }
-}
-/**
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
- */
-class privileged_services_PrivilegedServices {
-    manager;
-    delegator;
-    registrar;
-    assigners;
-    autoAccumulateServices;
-    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = descriptors_codec.Class(privileged_services_PrivilegedServices, {
-        manager: descriptors_codec.u32.asOpaque(),
-        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
-        delegator: descriptors_codec.u32.asOpaque(),
-        registrar: compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1)
-            ? descriptors_codec.u32.asOpaque()
-            : ignoreValueWithDefault(common_tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: readonlyArray(descriptors_codec.sequenceVarLen(privileged_services_AutoAccumulate.Codec)),
-    });
-    static create(a) {
-        return new privileged_services_PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
-    }
-    constructor(
-    /**
-     * `χ_M`: Manages alteration of χ from block to block,
-     * as well as bestow services with storage deposit credits.
-     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
-     */
-    manager, 
-    /** `χ_V`: Managers validator keys. */
-    delegator, 
-    /**
-     * `χ_R`: Manages the creation of services in protected range.
-     *
-     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
-     */
-    registrar, 
-    /** `χ_A`: Manages authorization queue one for each core. */
-    assigners, 
-    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    autoAccumulateServices) {
-        this.manager = manager;
-        this.delegator = delegator;
-        this.registrar = registrar;
-        this.assigners = assigners;
-        this.autoAccumulateServices = autoAccumulateServices;
-    }
-}
-
-;// 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
- * three additional historical values of the accumulator at
- * the point of each of the three most recently ended epochs,
- * η_1, η_2 and η_3. The second-oldest of these η2 is utilized to
- * help ensure future entropy is unbiased (see equation 6.29)
- * and seed the fallback seal-key generation function with
- * randomness (see equation 6.24). The oldest is used to re-
- * generate this randomness when verifying the seal above
- * (see equations 6.16 and 6.15).
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/0ef5010ef501
- */
-const ENTROPY_ENTRIES = 4;
-
-;// CONCATENATED MODULE: ./packages/jam/state/state-update.ts
-
-
-var state_update_UpdatePreimageKind;
-(function (UpdatePreimageKind) {
-    /** Insert new preimage and optionally update it's lookup history. */
-    UpdatePreimageKind[UpdatePreimageKind["Provide"] = 0] = "Provide";
-    /** Remove a preimage and it's lookup history. */
-    UpdatePreimageKind[UpdatePreimageKind["Remove"] = 1] = "Remove";
-    /** update or add lookup history for preimage hash/len to given value. */
-    UpdatePreimageKind[UpdatePreimageKind["UpdateOrAdd"] = 2] = "UpdateOrAdd";
-})(state_update_UpdatePreimageKind || (state_update_UpdatePreimageKind = {}));
-/**
- * A preimage update.
- *
- * Can be one of the following cases:
- * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
- * 2. Remove (expunge) a preimage and it's lookup history.
- * 3. Update `LookupHistory` with given value.
- */
-class state_update_UpdatePreimage {
-    serviceId;
-    action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
-        this.action = action;
-    }
-    /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
-    static provide({ serviceId, preimage, slot, }) {
-        return new state_update_UpdatePreimage(serviceId, {
-            kind: state_update_UpdatePreimageKind.Provide,
-            preimage,
-            slot,
-        });
-    }
-    /** The preimage should be removed completely from the database. */
-    static remove({ serviceId, hash, length }) {
-        return new state_update_UpdatePreimage(serviceId, {
-            kind: state_update_UpdatePreimageKind.Remove,
-            hash,
-            length,
-        });
-    }
-    /** Update the lookup history of some preimage or add a new one (request). */
-    static updateOrAdd({ serviceId, lookupHistory }) {
-        return new state_update_UpdatePreimage(serviceId, {
-            kind: state_update_UpdatePreimageKind.UpdateOrAdd,
-            item: lookupHistory,
-        });
-    }
-    get hash() {
-        switch (this.action.kind) {
-            case state_update_UpdatePreimageKind.Provide:
-                return this.action.preimage.hash;
-            case state_update_UpdatePreimageKind.Remove:
-                return this.action.hash;
-            case state_update_UpdatePreimageKind.UpdateOrAdd:
-                return this.action.item.hash;
-        }
-        throw assertNever(this.action);
-    }
-    get length() {
-        switch (this.action.kind) {
-            case state_update_UpdatePreimageKind.Provide:
-                return tryAsU32(this.action.preimage.blob.length);
-            case state_update_UpdatePreimageKind.Remove:
-                return this.action.length;
-            case state_update_UpdatePreimageKind.UpdateOrAdd:
-                return this.action.item.length;
-        }
-        throw assertNever(this.action);
-    }
-}
-/** The type of service update. */
-var state_update_UpdateServiceKind;
-(function (UpdateServiceKind) {
-    /** Just update the `ServiceAccountInfo`. */
-    UpdateServiceKind[UpdateServiceKind["Update"] = 0] = "Update";
-    /** Create a new `Service` instance. */
-    UpdateServiceKind[UpdateServiceKind["Create"] = 1] = "Create";
-})(state_update_UpdateServiceKind || (state_update_UpdateServiceKind = {}));
-/**
- * Update service info of a particular `ServiceId` or create a new one.
- */
-class state_update_UpdateService {
-    serviceId;
-    action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
-        this.action = action;
-    }
-    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 item.slots.length === 0;
         }
-        return this.action.storage.value;
+        return item.length === 0;
     }
 }
 
@@ -12526,73 +12341,377 @@ class statistics_ServiceStatistics {
     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;
+    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;
+    }
+}
+/**
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
+ */
+class privileged_services_PrivilegedServices {
+    manager;
+    delegator;
+    registrar;
+    assigners;
+    autoAccumulateServices;
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
+    static Codec = descriptors_codec.Class(privileged_services_PrivilegedServices, {
+        manager: descriptors_codec.u32.asOpaque(),
+        assigners: codecPerCore(descriptors_codec.u32.asOpaque()),
+        delegator: descriptors_codec.u32.asOpaque(),
+        registrar: compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_1)
+            ? descriptors_codec.u32.asOpaque()
+            : ignoreValueWithDefault(common_tryAsServiceId(2 ** 32 - 1)),
+        autoAccumulateServices: readonlyArray(descriptors_codec.sequenceVarLen(privileged_services_AutoAccumulate.Codec)),
+    });
+    static create(a) {
+        return new privileged_services_PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+    }
+    constructor(
+    /**
+     * `χ_M`: Manages alteration of χ from block to block,
+     * as well as bestow services with storage deposit credits.
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111502111902?v=0.7.2
+     */
+    manager, 
+    /** `χ_V`: Managers validator keys. */
+    delegator, 
+    /**
+     * `χ_R`: Manages the creation of services in protected range.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
+     */
+    registrar, 
+    /** `χ_A`: Manages authorization queue one for each core. */
+    assigners, 
+    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
+    autoAccumulateServices) {
+        this.manager = manager;
+        this.delegator = delegator;
+        this.registrar = registrar;
+        this.assigners = assigners;
+        this.autoAccumulateServices = autoAccumulateServices;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/state/state.ts
+/**
+ * In addition to the entropy accumulator η_0, we retain
+ * three additional historical values of the accumulator at
+ * the point of each of the three most recently ended epochs,
+ * η_1, η_2 and η_3. The second-oldest of these η2 is utilized to
+ * help ensure future entropy is unbiased (see equation 6.29)
+ * and seed the fallback seal-key generation function with
+ * randomness (see equation 6.24). The oldest is used to re-
+ * generate this randomness when verifying the seal above
+ * (see equations 6.16 and 6.15).
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/0ef5010ef501
+ */
+const ENTROPY_ENTRIES = 4;
+
+;// CONCATENATED MODULE: ./packages/jam/state/state-update.ts
+
+
+var state_update_UpdatePreimageKind;
+(function (UpdatePreimageKind) {
+    /** Insert new preimage and optionally update it's lookup history. */
+    UpdatePreimageKind[UpdatePreimageKind["Provide"] = 0] = "Provide";
+    /** Remove a preimage and it's lookup history. */
+    UpdatePreimageKind[UpdatePreimageKind["Remove"] = 1] = "Remove";
+    /** update or add lookup history for preimage hash/len to given value. */
+    UpdatePreimageKind[UpdatePreimageKind["UpdateOrAdd"] = 2] = "UpdateOrAdd";
+})(state_update_UpdatePreimageKind || (state_update_UpdatePreimageKind = {}));
+/**
+ * A preimage update.
+ *
+ * Can be one of the following cases:
+ * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
+ * 2. Remove (expunge) a preimage and it's lookup history.
+ * 3. Update `LookupHistory` with given value.
+ */
+class state_update_UpdatePreimage {
+    serviceId;
+    action;
+    constructor(serviceId, action) {
+        this.serviceId = serviceId;
+        this.action = action;
+    }
+    /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
+    static provide({ serviceId, preimage, slot, }) {
+        return new state_update_UpdatePreimage(serviceId, {
+            kind: state_update_UpdatePreimageKind.Provide,
+            preimage,
+            slot,
+        });
+    }
+    /** The preimage should be removed completely from the database. */
+    static remove({ serviceId, hash, length }) {
+        return new state_update_UpdatePreimage(serviceId, {
+            kind: state_update_UpdatePreimageKind.Remove,
+            hash,
+            length,
+        });
+    }
+    /** Update the lookup history of some preimage or add a new one (request). */
+    static updateOrAdd({ serviceId, lookupHistory }) {
+        return new state_update_UpdatePreimage(serviceId, {
+            kind: state_update_UpdatePreimageKind.UpdateOrAdd,
+            item: lookupHistory,
+        });
+    }
+    get hash() {
+        switch (this.action.kind) {
+            case state_update_UpdatePreimageKind.Provide:
+                return this.action.preimage.hash;
+            case state_update_UpdatePreimageKind.Remove:
+                return this.action.hash;
+            case state_update_UpdatePreimageKind.UpdateOrAdd:
+                return this.action.item.hash;
+        }
+        throw assertNever(this.action);
+    }
+    get length() {
+        switch (this.action.kind) {
+            case state_update_UpdatePreimageKind.Provide:
+                return tryAsU32(this.action.preimage.blob.length);
+            case state_update_UpdatePreimageKind.Remove:
+                return this.action.length;
+            case state_update_UpdatePreimageKind.UpdateOrAdd:
+                return this.action.item.length;
+        }
+        throw assertNever(this.action);
     }
-    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);
+}
+/** The type of service update. */
+var state_update_UpdateServiceKind;
+(function (UpdateServiceKind) {
+    /** Just update the `ServiceAccountInfo`. */
+    UpdateServiceKind[UpdateServiceKind["Update"] = 0] = "Update";
+    /** Create a new `Service` instance. */
+    UpdateServiceKind[UpdateServiceKind["Create"] = 1] = "Create";
+})(state_update_UpdateServiceKind || (state_update_UpdateServiceKind = {}));
+/**
+ * Update service info of a particular `ServiceId` or create a new one.
+ */
+class state_update_UpdateService {
+    serviceId;
+    action;
+    constructor(serviceId, action) {
+        this.serviceId = serviceId;
+        this.action = action;
+    }
+    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,
+        });
     }
 }
-/** `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);
+/** 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;
     }
-    constructor(current, previous, cores, services) {
-        this.current = current;
-        this.previous = previous;
-        this.cores = cores;
-        this.services = services;
+    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;
     }
 }
 
@@ -12617,6 +12736,7 @@ class statistics_StatisticsData {
 
 
 
+
 
 
 var in_memory_state_UpdateError;
@@ -12718,9 +12838,10 @@ 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 create(state) {
-        return new InMemoryState(state);
+    static new(chainSpec, state) {
+        return new InMemoryState(chainSpec, state);
     }
     /**
      * Create a new `InMemoryState` with a partial state override.
@@ -12736,7 +12857,7 @@ class InMemoryState extends WithDebug {
     /**
      * Create a new `InMemoryState` from some other state object.
      */
-    static copyFrom(other, servicesData) {
+    static copyFrom(chainSpec, other, servicesData) {
         const services = new Map();
         for (const [id, entries] of servicesData.entries()) {
             const service = other.getService(id);
@@ -12746,7 +12867,7 @@ class InMemoryState extends WithDebug {
             const inMemService = InMemoryService.copyFrom(service, entries);
             services.set(id, inMemService);
         }
-        return InMemoryState.create({
+        return InMemoryState.new(chainSpec, {
             availabilityAssignment: other.availabilityAssignment,
             accumulationQueue: other.accumulationQueue,
             designatedValidatorData: other.designatedValidatorData,
@@ -12943,8 +13064,9 @@ class InMemoryState extends WithDebug {
     getService(id) {
         return this.services.get(id) ?? null;
     }
-    constructor(s) {
+    constructor(chainSpec, s) {
         super();
+        this.chainSpec = chainSpec;
         this.availabilityAssignment = s.availabilityAssignment;
         this.designatedValidatorData = s.designatedValidatorData;
         this.nextValidatorData = s.nextValidatorData;
@@ -12966,11 +13088,14 @@ class InMemoryState extends WithDebug {
         this.accumulationOutputLog = s.accumulationOutputLog;
         this.services = s.services;
     }
+    view() {
+        return new InMemoryStateView(this.chainSpec, this);
+    }
     /**
      * Create an empty and possibly incoherent `InMemoryState`.
      */
     static empty(spec) {
-        return new InMemoryState({
+        return new InMemoryState(spec, {
             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(),
@@ -13005,8 +13130,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(), gp_constants_AUTHORIZATION_QUEUE_SIZE)), spec),
-            recentBlocks: recent_blocks_RecentBlocksHistory.empty(),
+            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(),
             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),
@@ -13057,6 +13182,10 @@ const serviceDataCodec = descriptors_codec.dictionary(descriptors_codec.u32.asOp
 
 
 
+
+
+
+
 ;// CONCATENATED MODULE: ./packages/jam/state-json/accounts.ts
 
 
@@ -13228,51 +13357,6 @@ 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
 
 
@@ -13280,7 +13364,7 @@ class not_yet_accumulated_NotYetAccumulatedReport extends WithDebug {
 const notYetAccumulatedFromJson = json.object({
     report: workReportFromJson,
     dependencies: json.array(fromJson.bytes32()),
-}, ({ report, dependencies }) => not_yet_accumulated_NotYetAccumulatedReport.create({ report, dependencies }));
+}, ({ report, dependencies }) => accumulation_queue_NotYetAccumulatedReport.create({ report, dependencies }));
 
 ;// CONCATENATED MODULE: ./packages/jam/state-json/recent-history.ts
 
@@ -13313,10 +13397,10 @@ const recentBlocksHistoryFromJson = json.object({
         peaks: json.array(json.nullable(fromJson.bytes32())),
     },
 }, ({ history, mmr }) => {
-    return recent_blocks_RecentBlocksHistory.create(recent_blocks_RecentBlocks.create({
+    return recent_blocks_RecentBlocks.create({
         blocks: history,
         accumulationLog: mmr,
-    }));
+    });
 });
 
 ;// CONCATENATED MODULE: ./packages/jam/state-json/safrole.ts
@@ -13514,7 +13598,6 @@ const validatorDataFromJson = json.object({
 
 
 
-
 const fullStateDumpFromJson = (spec) => json.object({
     alpha: json.array(json.array(fromJson.bytes32())),
     varphi: json.array(json.array(fromJson.bytes32())),
@@ -13551,20 +13634,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.create({
+    return InMemoryState.new(spec, {
         authPools: common_tryAsPerCore(alpha.map((perCore) => {
-            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}`);
+            if (perCore.length > auth_MAX_AUTH_POOL_SIZE) {
+                throw new Error(`AuthPools: expected less than ${auth_MAX_AUTH_POOL_SIZE}, got ${perCore.length}`);
             }
             return sized_array_asKnownSize(perCore);
         }), spec),
         authQueues: common_tryAsPerCore(varphi.map((perCore) => {
-            if (perCore.length !== gp_constants_AUTHORIZATION_QUEUE_SIZE) {
-                throw new Error(`AuthQueues: expected ${gp_constants_AUTHORIZATION_QUEUE_SIZE}, got: ${perCore.length}`);
+            if (perCore.length !== auth_AUTHORIZATION_QUEUE_SIZE) {
+                throw new Error(`AuthQueues: expected ${auth_AUTHORIZATION_QUEUE_SIZE}, got: ${perCore.length}`);
             }
             return sized_array_asKnownSize(perCore);
         }), spec),
-        recentBlocks: beta ?? recent_blocks_RecentBlocksHistory.empty(),
+        recentBlocks: beta ?? recent_blocks_RecentBlocks.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -13778,26 +13861,19 @@ 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: 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,
-        })),
+        Codec: authPoolsCodec,
         extract: (s) => s.authPools,
     };
     /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
     serialize.authQueues = {
         key: stateKeys.index(StateKeyIdx.Phi),
-        Codec: codecPerCore(codecFixedSizeArray(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(), gp_constants_AUTHORIZATION_QUEUE_SIZE)),
+        Codec: authQueuesCodec,
         extract: (s) => s.authQueues,
     };
     /**
@@ -13806,7 +13882,7 @@ var serialize_serialize;
      */
     serialize.recentBlocks = {
         key: stateKeys.index(StateKeyIdx.Beta),
-        Codec: recent_blocks_RecentBlocksHistory.Codec,
+        Codec: recent_blocks_RecentBlocks.Codec,
         extract: (s) => s.recentBlocks,
     };
     /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
@@ -13835,25 +13911,25 @@ var serialize_serialize;
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
     serialize.designatedValidators = {
         key: stateKeys.index(StateKeyIdx.Iota),
-        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.designatedValidatorData,
     };
     /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
     serialize.currentValidators = {
         key: stateKeys.index(StateKeyIdx.Kappa),
-        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.currentValidatorData,
     };
     /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
     serialize.previousValidators = {
         key: stateKeys.index(StateKeyIdx.Lambda),
-        Codec: codecPerValidator(validator_data_ValidatorData.Codec),
+        Codec: validatorsDataCodec,
         extract: (s) => s.previousValidatorData,
     };
     /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
     serialize.availabilityAssignment = {
         key: stateKeys.index(StateKeyIdx.Rho),
-        Codec: codecPerCore(descriptors_codec.optional(assurances_AvailabilityAssignment.Codec)),
+        Codec: availabilityAssignmentsCodec,
         extract: (s) => s.availabilityAssignment,
     };
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
@@ -13877,13 +13953,13 @@ var serialize_serialize;
     /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
     serialize.accumulationQueue = {
         key: stateKeys.index(StateKeyIdx.Omega),
-        Codec: codecPerEpochBlock(readonlyArray(descriptors_codec.sequenceVarLen(not_yet_accumulated_NotYetAccumulatedReport.Codec))),
+        Codec: accumulationQueueCodec,
         extract: (s) => s.accumulationQueue,
     };
     /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
     serialize.recentlyAccumulated = {
         key: stateKeys.index(StateKeyIdx.Xi),
-        Codec: codecPerEpochBlock(descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => hash_set_HashSet.from(x))),
+        Codec: recentlyAccumulatedCodec,
         extract: (s) => s.recentlyAccumulated,
     };
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
@@ -13902,12 +13978,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: serialize_dumpCodec,
+        Codec: dumpCodec,
     });
     /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
     serialize.servicePreimages = (blake2b, serviceId, hash) => ({
         key: stateKeys.servicePreimage(blake2b, serviceId, hash),
-        Codec: serialize_dumpCodec,
+        Codec: dumpCodec,
     });
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
@@ -13922,7 +13998,88 @@ 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 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()));
+const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
+
+;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state-view.ts
+
+
+class SerializedStateView {
+    spec;
+    backend;
+    recentlyUsedServices;
+    viewCache;
+    constructor(spec, backend, 
+    /** Best-effort list of recently active services. */
+    recentlyUsedServices, viewCache) {
+        this.spec = spec;
+        this.backend = backend;
+        this.recentlyUsedServices = recentlyUsedServices;
+        this.viewCache = viewCache;
+    }
+    retrieveView({ key, Codec }, description) {
+        const cached = this.viewCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const bytes = this.backend.get(key);
+        if (bytes === null) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing view of key: ${key}`);
+        }
+        // NOTE [ToDr] we are not using `Decoder.decodeObject` here because
+        // it needs to get to the end of the data (skip), yet that's expensive.
+        // we assume that the state data is correct and coherent anyway, so
+        // for performance reasons we simply create the view here.
+        const d = decoder_Decoder.fromBytesBlob(bytes);
+        d.attachContext(this.spec);
+        const view = Codec.View.decode(d);
+        this.viewCache.set(key, view);
+        return view;
+    }
+    availabilityAssignmentView() {
+        return this.retrieveView(serialize_serialize.availabilityAssignment, "availabilityAssignmentView");
+    }
+    designatedValidatorDataView() {
+        return this.retrieveView(serialize_serialize.designatedValidators, "designatedValidatorsView");
+    }
+    currentValidatorDataView() {
+        return this.retrieveView(serialize_serialize.currentValidators, "currentValidatorsView");
+    }
+    previousValidatorDataView() {
+        return this.retrieveView(serialize_serialize.previousValidators, "previousValidatorsView");
+    }
+    authPoolsView() {
+        return this.retrieveView(serialize_serialize.authPools, "authPoolsView");
+    }
+    authQueuesView() {
+        return this.retrieveView(serialize_serialize.authQueues, "authQueuesView");
+    }
+    recentBlocksView() {
+        return this.retrieveView(serialize_serialize.recentBlocks, "recentBlocksView");
+    }
+    statisticsView() {
+        return this.retrieveView(serialize_serialize.statistics, "statisticsView");
+    }
+    accumulationQueueView() {
+        return this.retrieveView(serialize_serialize.accumulationQueue, "accumulationQueueView");
+    }
+    recentlyAccumulatedView() {
+        return this.retrieveView(serialize_serialize.recentlyAccumulated, "recentlyAccumulatedView");
+    }
+    safroleDataView() {
+        return this.retrieveView(serialize_serialize.safrole, "safroleDataView");
+    }
+    getServiceInfoView(id) {
+        const serviceData = serialize_serialize.serviceData(id);
+        const bytes = this.backend.get(serviceData.key);
+        if (bytes === null) {
+            return null;
+        }
+        if (!this.recentlyUsedServices.includes(id)) {
+            this.recentlyUsedServices.push(id);
+        }
+        return decoder_Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
+    }
+}
 
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state.ts
 
@@ -13932,6 +14089,8 @@ const serialize_dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }
 
 
 
+
+
 /**
  * State object which reads it's entries from some backend.
  *
@@ -13944,7 +14103,7 @@ class serialized_state_SerializedState {
     spec;
     blake2b;
     backend;
-    _recentServiceIds;
+    recentlyUsedServices;
     /** Create a state-like object from collection of serialized entries. */
     static fromStateEntries(spec, blake2b, state, recentServices = []) {
         return new serialized_state_SerializedState(spec, blake2b, state, recentServices);
@@ -13953,49 +14112,63 @@ class serialized_state_SerializedState {
     static new(spec, blake2b, db, recentServices = []) {
         return new serialized_state_SerializedState(spec, blake2b, db, recentServices);
     }
+    dataCache = hash_dictionary_HashDictionary.new();
+    viewCache = hash_dictionary_HashDictionary.new();
     constructor(spec, blake2b, backend, 
     /** Best-effort list of recently active services. */
-    _recentServiceIds) {
+    recentlyUsedServices) {
         this.spec = spec;
         this.blake2b = blake2b;
         this.backend = backend;
-        this._recentServiceIds = _recentServiceIds;
+        this.recentlyUsedServices = recentlyUsedServices;
     }
     /** Comparing the serialized states, just means comparing their backends. */
     [TEST_COMPARE_USING]() {
         return this.backend;
     }
+    /** Return a non-decoding version of the state. */
+    view() {
+        return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
+    }
     // TODO [ToDr] Temporary method to update the state,
     // without changing references.
     updateBackend(newBackend) {
         this.backend = newBackend;
+        this.dataCache = hash_dictionary_HashDictionary.new();
+        this.viewCache = hash_dictionary_HashDictionary.new();
     }
     recentServiceIds() {
-        return this._recentServiceIds;
+        return this.recentlyUsedServices;
     }
     getService(id) {
         const serviceData = this.retrieveOptional(serialize_serialize.serviceData(id));
         if (serviceData === undefined) {
             return null;
         }
-        if (!this._recentServiceIds.includes(id)) {
-            this._recentServiceIds.push(id);
+        if (!this.recentlyUsedServices.includes(id)) {
+            this.recentlyUsedServices.push(id);
         }
         return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
     }
-    retrieve({ key, Codec }, description) {
-        const bytes = this.backend.get(key);
-        if (bytes === null) {
-            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${key}`);
+    retrieve(k, description) {
+        const data = this.retrieveOptional(k);
+        if (data === undefined) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${k.key}`);
         }
-        return decoder_Decoder.decodeObject(Codec, bytes, this.spec);
+        return data;
     }
     retrieveOptional({ key, Codec }) {
+        const cached = this.dataCache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
         const bytes = this.backend.get(key);
         if (bytes === null) {
             return undefined;
         }
-        return decoder_Decoder.decodeObject(Codec, bytes, this.spec);
+        const data = decoder_Decoder.decodeObject(Codec, bytes, this.spec);
+        this.dataCache.set(key, data);
+        return data;
     }
     get availabilityAssignment() {
         return this.retrieve(serialize_serialize.availabilityAssignment, "availabilityAssignment");
@@ -15110,6 +15283,7 @@ function loader_loadState(spec, blake2b, entries) {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/in-memory-state-codec.ts
 
 
@@ -15214,7 +15388,11 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const in_memory_state_codec_inMemoryStateCodec = descriptors_codec.Class(InMemoryState, {
+const in_memory_state_codec_inMemoryStateCodec = (spec) => descriptors_codec.Class(class State extends InMemoryState {
+    static create(data) {
+        return InMemoryState.new(spec, data);
+    }
+}, {
     // alpha
     authPools: serialize_serialize.authPools.Codec,
     // phi
@@ -15450,7 +15628,7 @@ class InMemoryStates {
     }
     /** Insert a full state into the database. */
     async insertState(headerHash, state) {
-        const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
+        const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
         this.db.set(headerHash, encoded);
         return Result.ok(OK);
     }
@@ -15459,7 +15637,7 @@ class InMemoryStates {
         if (encodedState === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
+        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
     }
 }
 
@@ -15502,21 +15680,21 @@ class hasher_TransitionHasher {
      */
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-        const guarantees = extrinsicView.guarantees
+        const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
+        const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
+        const guaranteesBlobs = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
-            .map((guarantee) => {
+            .reduce((aggregated, guarantee) => {
             const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque();
-            return BytesBlob.blobFromParts([
-                reportHash.raw,
-                guarantee.slot.encoded().raw,
-                guarantee.credentials.encoded().raw,
-            ]);
-        });
-        const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
+            aggregated.push(reportHash.raw);
+            aggregated.push(guarantee.slot.encoded().raw);
+            aggregated.push(guarantee.credentials.encoded().raw);
+            return aggregated;
+        }, [countEncoded.raw]);
         const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque();
         const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque();
-        const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque();
+        const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque();
         const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
         const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
         const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);
@@ -16639,47 +16817,46 @@ class safrole_seal_SafroleSeal {
     }
     async verifySeal(headerView, state) {
         // we use transitioned keys already
-        const validators = state.currentValidatorData;
         const validatorIndex = headerView.bandersnatchBlockAuthorIndex.materialize();
-        const authorKey = validators[validatorIndex];
-        if (authorKey === undefined) {
+        const authorKeys = state.currentValidatorData.at(validatorIndex);
+        if (authorKeys === undefined) {
             return Result.error(SafroleSealError.InvalidValidatorIndex);
         }
         const timeSlot = headerView.timeSlotIndex.materialize();
         const sealingKeys = state.sealingKeySeries;
         const entropy = state.currentEntropy;
         if (sealingKeys.kind === SafroleSealingKeysKind.Tickets) {
-            return await this.verifySealWithTicket(sealingKeys.tickets, timeSlot, entropy, validators, validatorIndex, headerView);
+            return await this.verifySealWithTicket(sealingKeys.tickets, timeSlot, entropy, authorKeys, headerView);
         }
-        return await this.verifySealWithKeys(sealingKeys.keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView);
+        return await this.verifySealWithKeys(sealingKeys.keys, timeSlot, entropy, authorKeys, headerView);
     }
     /** Regular (non-fallback) mode of Safrole. */
-    async verifySealWithTicket(tickets, timeSlot, entropy, validators, validatorIndex, headerView) {
+    async verifySealWithTicket(tickets, timeSlot, entropy, validatorData, headerView) {
         const index = timeSlot % tickets.length;
-        const { id, attempt } = tickets[index];
-        const payload = BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([attempt]));
+        const ticket = tickets.at(index);
+        const payload = BytesBlob.blobFromParts(JAM_TICKET_SEAL, entropy.raw, new Uint8Array([ticket?.attempt ?? 0]));
         // verify seal correctness
-        const authorKey = validators.at(validatorIndex)?.bandersnatch;
+        const authorKey = validatorData.bandersnatch;
         const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, authorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return Result.error(SafroleSealError.IncorrectSeal);
         }
-        if (!id.isEqualTo(result.ok)) {
+        if (ticket === undefined || !ticket.id.isEqualTo(result.ok)) {
             return Result.error(SafroleSealError.InvalidTicket);
         }
         return Result.ok(result.ok);
     }
     /** Fallback mode of Safrole. */
-    async verifySealWithKeys(keys, authorKey, timeSlot, entropy, validators, validatorIndex, headerView) {
+    async verifySealWithKeys(keys, timeSlot, entropy, authorKey, headerView) {
         const index = timeSlot % keys.length;
-        const sealingKey = keys[index];
-        if (!sealingKey.isEqualTo(authorKey.bandersnatch)) {
+        const sealingKey = keys.at(index);
+        const authorBandersnatchKey = authorKey.bandersnatch;
+        if (sealingKey === undefined || !sealingKey.isEqualTo(authorBandersnatchKey)) {
             return Result.error(SafroleSealError.InvalidValidator, `Invalid Validator. Expected: ${sealingKey}, got: ${authorKey.bandersnatch}`);
         }
         // verify seal correctness
         const payload = BytesBlob.blobFromParts(JAM_FALLBACK_SEAL, entropy.raw);
-        const blockAuthorKey = validators.at(validatorIndex)?.bandersnatch;
-        const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, blockAuthorKey ?? BANDERSNATCH_ZERO_KEY, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
+        const result = await bandersnatchVrf.verifySeal(await this.bandersnatch, authorBandersnatchKey, headerView.seal.materialize(), payload, encodeUnsealedHeader(headerView));
         if (result.isError) {
             return Result.error(SafroleSealError.IncorrectSeal);
         }
@@ -22558,7 +22735,7 @@ class Assign {
         const authorizationQueueStart = regs.get(8);
         // a
         const assigners = getServiceId(regs.get(9));
-        const res = safe_alloc_uint8array_safeAllocUint8Array(hash_HASH_SIZE * gp_constants_AUTHORIZATION_QUEUE_SIZE);
+        const res = safe_alloc_uint8array_safeAllocUint8Array(hash_HASH_SIZE * auth_AUTHORIZATION_QUEUE_SIZE);
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
@@ -22572,8 +22749,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), gp_constants_AUTHORIZATION_QUEUE_SIZE);
-        const fixedSizeAuthQueue = sized_array_FixedSizeArray.new(authQueue, gp_constants_AUTHORIZATION_QUEUE_SIZE);
+        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 result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
             regs.set(IN_OUT_REG, results_HostCallResult.OK);
@@ -24319,9 +24496,10 @@ 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 - this.state.timeslot) {
+            if (i < slot - timeslot) {
                 accumulationQueue[queueIndex] = [];
             }
             else {
@@ -24533,7 +24711,6 @@ class deferred_transfers_DeferredTransfers {
 
 
 
-
 /**
  * Maintain a list of available authorizations per core.
  *
@@ -24562,11 +24739,12 @@ 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 = this.state.authQueues[coreIndex];
+            const queue = authQueues[coreIndex];
             // if there were any used hashes - remove them
             const usedHashes = input.used.get(coreIndex);
             if (usedHashes !== undefined) {
@@ -24740,14 +24918,18 @@ class recent_history_RecentHistory {
      * https://graypaper.fluffylabs.dev/#/1c979cb/0f55020f5502?v=0.7.1
      */
     partialTransition(input) {
-        const recentBlocks = this.state.recentBlocks.blocks.slice();
+        const stateBlocks = this.state.recentBlocks;
+        const recentBlocks = stateBlocks.blocks.slice();
         const lastState = recentBlocks.length > 0 ? recentBlocks[recentBlocks.length - 1] : null;
         // update the posterior root of previous state.
         if (lastState !== null) {
             lastState.postStateRoot = input.priorStateRoot;
         }
         return {
-            recentBlocks: this.state.recentBlocks.updateBlocks(recentBlocks), // β_H†
+            recentBlocks: RecentBlocks.create({
+                blocks: asKnownSize(recentBlocks),
+                accumulationLog: stateBlocks.accumulationLog,
+            }), // β_H†
         };
     }
     /**
@@ -24759,8 +24941,8 @@ class recent_history_RecentHistory {
     transition(input) {
         const recentBlocks = input.partial.recentBlocks.blocks.slice();
         // `β′_B`
-        const mmr = this.state.recentBlocks.asCurrent().accumulationLog !== null
-            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.asCurrent().accumulationLog)
+        const mmr = this.state.recentBlocks.accumulationLog !== null
+            ? MerkleMountainRange.fromPeaks(this.hasher, this.state.recentBlocks.accumulationLog)
             : MerkleMountainRange.empty(this.hasher);
         // append the accumulation root
         mmr.append(input.accumulateRoot);
@@ -24778,7 +24960,7 @@ class recent_history_RecentHistory {
         }
         // write back to the state.
         return {
-            recentBlocks: RecentBlocksHistory.create(RecentBlocks.create({
+            recentBlocks: RecentBlocks.create(RecentBlocks.create({
                 blocks: asKnownSize(recentBlocks),
                 accumulationLog: peaks,
             })),
@@ -24990,7 +25172,6 @@ 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) {
@@ -25103,7 +25284,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 = RecentBlocksHistory.accumulationResult(recentBlock);
+        const beefyRoot = recentBlock.accumulationResult;
         if (!beefyRoot.isEqualTo(context.beefyRoot)) {
             return Result.error(ReportsError.BadBeefyMmrRoot, `Invalid BEEFY super peak hash. Got: ${context.beefyRoot}, expected: ${beefyRoot}. Anchor: ${recentBlock.headerHash}`);
         }
@@ -25345,8 +25526,9 @@ function verify_post_signature_verifyPostSignatureChecks(input, availabilityAssi
          * https://graypaper.fluffylabs.dev/#/5f542d7/15eb0015ed00
          */
         const authorizerHash = report.authorizerHash;
-        const authorizerPool = authPools[coreIndex];
-        if (authorizerPool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
+        const authorizerPool = authPools.get(coreIndex);
+        const pool = authorizerPool?.materialize() ?? [];
+        if (pool.find((hash) => hash.isEqualTo(authorizerHash)) === undefined) {
             return Result.error(ReportsError.CoreUnauthorized, `Authorizer hash not found in the pool of core ${coreIndex}: ${authorizerHash}`);
         }
         /**
@@ -25476,7 +25658,8 @@ class reports_Reports {
         return verifyCredentials(input.guarantees, workReportHashes, input.slot, (headerTimeSlot, guaranteeTimeSlot) => this.getGuarantorAssignment(headerTimeSlot, guaranteeTimeSlot, input.newEntropy));
     }
     verifyPostSignatureChecks(input, assurancesAvailAssignment) {
-        return verifyPostSignatureChecks(input, assurancesAvailAssignment, this.state.authPools, (id) => this.state.getService(id));
+        const authPoolsView = this.state.view().authPoolsView();
+        return verifyPostSignatureChecks(input, assurancesAvailAssignment, authPoolsView, (id) => this.state.getService(id));
     }
     verifyContextualValidity(input) {
         return verifyContextualValidity(input, this.state, this.headerChain, this.chainSpec.maxLookupAnchorAge);
@@ -27038,18 +27221,20 @@ 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 encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
+            const encoder = typeof type.encode === "function" ? type.encode(spec) : type.encode;
+            const encoded = encoder_Encoder.encodeObject(encoder, data, spec);
             dump(`${encoded}`);
             return;
         }
         case OutputFormat.Bin: {
-            if (type.encode === undefined) {
-                throw new Error(`${type.name} does not support encoding to JAM codec.`);
-            }
             if (destination === null) {
                 throw new Error(`${OutputFormat.Bin} requires destination file.`);
             }
-            const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
+            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);
             dump(encoded.raw);
             return;
         }
@@ -27156,7 +27341,8 @@ async function loadAndProcessDataFile(file, withRelPath, flavor, decodeType, pro
         if (decodeType.decode === undefined) {
             throw new Error(`${decodeType.name} does not support decoding from binary data.`);
         }
-        data = decoder_Decoder.decodeObject(decodeType.decode, input.data, spec);
+        const decoder = typeof decodeType.decode === "function" ? decodeType.decode(spec) : decodeType.decode;
+        data = decoder_Decoder.decodeObject(decoder, input.data, spec);
     }
     else if (input.type === "json") {
         if (decodeType.json === undefined) {