@typeberry/lib 0.2.0-e767e74 → 0.2.0

package/index.js

@@ -2088,9 +2088,6 @@ class ObjectView {
     toString() {
         return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
     }
-    [TEST_COMPARE_USING]() {
-        return this.materialize();
-    }
 }
 /**
  * A lazy-evaluated decoder of a sequence.
@@ -2376,15 +2373,7 @@ var codec$1;
     /** Custom encoding / decoding logic. */
     codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
     /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => {
-        const Self = chooser(null);
-        return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
-            ? codec.select({
-                name: Self.View.name,
-                sizeHint: Self.View.sizeHint,
-            }, (ctx) => chooser(ctx).View)
-            : Self.View);
-    };
+    codec.select = ({ name, sizeHint, }, chooser) => Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), chooser(null).View);
     /**
      * A descriptor for a more complex POJO.
      *
@@ -6683,17 +6672,6 @@ function emptyBlock(slot = tryAsTimeSlot(0)) {
     });
 }
 
-/**
- * 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.encodeObject(codec, object, chainSpec);
-    return Decoder.decodeObject(codec.View, encoded, chainSpec);
-}
-
 var index$l = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Block: Block,
@@ -6714,7 +6692,6 @@ var index$l = /*#__PURE__*/Object.freeze({
   guarantees: guarantees,
   headerViewWithHashCodec: headerViewWithHashCodec,
   preimage: preimage,
-  reencodeAsView: reencodeAsView,
   refineContext: refineContext,
   tickets: tickets,
   tryAsCoreIndex: tryAsCoreIndex,
@@ -8065,70 +8042,6 @@ function accumulationOutputComparator(a, b) {
     return Ordering.Equal;
 }
 
-/** `O`: Maximum number of items in the authorizations pool. */
-const O = 8;
-/** `Q`: The number of items in the authorizations queue. */
-const Q = 80;
-/** `W_T`: The size of a transfer memo in octets. */
-const W_T = 128;
-/**
- * `J`: The maximum sum of dependency items in a work-report.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
- */
-const MAX_REPORT_DEPENDENCIES = 8;
-
-/**
- * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
- */
-class NotYetAccumulatedReport extends WithDebug {
-    report;
-    dependencies;
-    static Codec = codec$1.Class(NotYetAccumulatedReport, {
-        report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), {
-            typicalLength: MAX_REPORT_DEPENDENCIES / 2,
-            maxLength: MAX_REPORT_DEPENDENCIES,
-            minLength: 0,
-        }),
-    });
-    static create({ report, dependencies }) {
-        return new NotYetAccumulatedReport(report, dependencies);
-    }
-    constructor(
-    /**
-     * Each of these were made available at most one epoch ago
-     * but have or had unfulfilled dependencies.
-     */
-    report, 
-    /**
-     * Alongside the work-report itself, we retain its un-accumulated
-     * dependencies, a set of work-package hashes.
-     *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
-     */
-    dependencies) {
-        super();
-        this.report = report;
-        this.dependencies = dependencies;
-    }
-}
-const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(codec$1.sequenceVarLen(NotYetAccumulatedReport.Codec)));
-
-/** Check if given array has correct length before casting to the opaque type. */
-function tryAsPerCore(array, spec) {
-    check `
-    ${array.length === spec.coresCount}
-    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
-  `;
-    return asOpaqueType(array);
-}
-const codecPerCore = (val) => codecWithContext((context) => {
-    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
-});
-
 /**
  * Assignment of particular work report to a core.
  *
@@ -8157,18 +8070,18 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(codec$1.optional(AvailabilityAssignment.Codec));
 
-/** `O`: Maximal authorization pool size. */
-const MAX_AUTH_POOL_SIZE = O;
-/** `Q`: Size of the authorization queue. */
-const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), {
-    minLength: 0,
-    maxLength: MAX_AUTH_POOL_SIZE,
-    typicalLength: MAX_AUTH_POOL_SIZE,
-}));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+/** Check if given array has correct length before casting to the opaque type. */
+function tryAsPerCore(array, spec) {
+    check `
+    ${array.length === spec.coresCount}
+    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
+  `;
+    return asOpaqueType(array);
+}
+const codecPerCore = (val) => codecWithContext((context) => {
+    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
+});
 
 const sortedSetCodec = () => readonlyArray(codec$1.sequenceVarLen(codec$1.bytes(HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
@@ -8232,297 +8145,99 @@ function hashComparator(a, b) {
     return a.compare(b);
 }
 
+/** `O`: Maximum number of items in the authorizations pool. */
+const O = 8;
+/** `Q`: The number of items in the authorizations queue. */
+const Q = 80;
+/** `W_T`: The size of a transfer memo in octets. */
+const W_T = 128;
+/**
+ * `J`: The maximum sum of dependency items in a work-report.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
+ */
+const MAX_REPORT_DEPENDENCIES = 8;
+/** `Q`: Size of the authorization queue. */
+const AUTHORIZATION_QUEUE_SIZE = Q;
+/** `O`: Maximal authorization pool size. */
+const MAX_AUTH_POOL_SIZE = O;
+
 const MAX_VALUE = 4294967295;
 const MIN_VALUE = -2147483648;
 const MAX_SHIFT_U32 = 32;
 const MAX_SHIFT_U64 = 64n;
 
 /**
- * `H = 8`: The size of recent history, in blocks.
+ * `B_S`: The basic minimum balance which all services require.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
  */
-const MAX_RECENT_HISTORY = 8;
-/** Recent history of a single block. */
-class BlockState extends WithDebug {
-    headerHash;
-    accumulationResult;
-    postStateRoot;
-    reported;
-    static Codec = codec$1.Class(BlockState, {
-        headerHash: codec$1.bytes(HASH_SIZE).asOpaque(),
-        accumulationResult: codec$1.bytes(HASH_SIZE),
-        postStateRoot: codec$1.bytes(HASH_SIZE).asOpaque(),
-        reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
-    });
-    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
-        return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
-    }
-    constructor(
-    /** Header hash. */
-    headerHash, 
-    /** Merkle mountain belt of accumulation result. */
-    accumulationResult, 
-    /** Posterior state root filled in with a 1-block delay. */
-    postStateRoot, 
-    /** Reported work packages (no more than number of cores). */
-    reported) {
-        super();
-        this.headerHash = headerHash;
-        this.accumulationResult = accumulationResult;
-        this.postStateRoot = postStateRoot;
-        this.reported = reported;
-    }
-}
+const BASE_SERVICE_BALANCE = 100n;
 /**
- * Recent history of blocks.
+ * `B_I`: The additional minimum balance required per item of elective service state.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
  */
-class RecentBlocks extends WithDebug {
-    blocks;
-    accumulationLog;
-    static Codec = codec$1.Class(RecentBlocks, {
-        blocks: codecKnownSizeArray(BlockState.Codec, {
-            minLength: 0,
-            maxLength: MAX_RECENT_HISTORY,
-            typicalLength: MAX_RECENT_HISTORY,
-        }),
-        accumulationLog: codec$1.object({
-            peaks: readonlyArray(codec$1.sequenceVarLen(codec$1.optional(codec$1.bytes(HASH_SIZE)))),
-        }),
-    });
-    static empty() {
-        return new RecentBlocks(asKnownSize([]), {
-            peaks: [],
-        });
-    }
-    static create(a) {
-        return new RecentBlocks(a.blocks, a.accumulationLog);
-    }
-    constructor(
-    /**
-     * Most recent blocks.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fea010fea01?v=0.6.7
-     */
-    blocks, 
-    /**
-     * Accumulation output log.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0f02020f0202?v=0.6.7
-     */
-    accumulationLog) {
-        super();
-        this.blocks = blocks;
-        this.accumulationLog = accumulationLog;
-    }
-}
-
-const recentlyAccumulatedCodec = codecPerEpochBlock(codec$1.sequenceVarLen(codec$1.bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
-
+const ELECTIVE_ITEM_BALANCE = 10n;
 /**
- * Fixed size of validator metadata.
+ * `B_L`: The additional minimum balance required per octet of elective service state.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
  */
-const VALIDATOR_META_BYTES = 128;
+const ELECTIVE_BYTE_BALANCE = 1n;
+const zeroSizeHint = {
+    bytes: 0,
+    isExact: true,
+};
+/** 0-byte read, return given default value */
+const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
+/** Encode and decode object with leading version number. */
+const codecWithVersion = (val) => Descriptor.new("withVersion", {
+    bytes: val.sizeHint.bytes + 8,
+    isExact: false,
+}, (e, v) => {
+    e.varU64(0n);
+    val.encode(e, v);
+}, (d) => {
+    const version = d.varU64();
+    if (version !== 0n) {
+        throw new Error("Non-zero version is not supported!");
+    }
+    return val.decode(d);
+}, (s) => {
+    s.varU64();
+    val.skip(s);
+});
 /**
- * Details about validators' identity.
+ * Service account details.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
  */
-class ValidatorData extends WithDebug {
-    bandersnatch;
-    ed25519;
-    bls;
-    metadata;
-    static Codec = codec$1.Class(ValidatorData, {
-        bandersnatch: codec$1.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: codec$1.bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: codec$1.bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: codec$1.bytes(VALIDATOR_META_BYTES),
+class ServiceAccountInfo extends WithDebug {
+    codeHash;
+    balance;
+    accumulateMinGas;
+    onTransferMinGas;
+    storageUtilisationBytes;
+    gratisStorage;
+    storageUtilisationCount;
+    created;
+    lastAccumulation;
+    parentService;
+    static Codec = codec$1.Class(ServiceAccountInfo, {
+        codeHash: codec$1.bytes(HASH_SIZE).asOpaque(),
+        balance: codec$1.u64,
+        accumulateMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
+        onTransferMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
+        storageUtilisationBytes: codec$1.u64,
+        gratisStorage: codec$1.u64,
+        storageUtilisationCount: codec$1.u32,
+        created: codec$1.u32.convert((x) => x, tryAsTimeSlot),
+        lastAccumulation: codec$1.u32.convert((x) => x, tryAsTimeSlot),
+        parentService: codec$1.u32.convert((x) => x, tryAsServiceId),
     });
-    static create({ ed25519, bandersnatch, bls, metadata }) {
-        return new ValidatorData(bandersnatch, ed25519, bls, metadata);
-    }
-    constructor(
-    /** Bandersnatch public key. */
-    bandersnatch, 
-    /** ED25519 key data. */
-    ed25519, 
-    /** BLS public key. */
-    bls, 
-    /** Validator-defined additional metdata. */
-    metadata) {
-        super();
-        this.bandersnatch = bandersnatch;
-        this.ed25519 = ed25519;
-        this.bls = bls;
-        this.metadata = metadata;
-    }
-}
-const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
-
-var SafroleSealingKeysKind;
-(function (SafroleSealingKeysKind) {
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
-    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
-})(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = codec$1.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
-class SafroleSealingKeysData extends WithDebug {
-    kind;
-    keys;
-    tickets;
-    static Codec = codecWithContext((context) => {
-        return codec$1.custom({
-            name: "SafroleSealingKeys",
-            sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
-        }, (e, x) => {
-            e.varU32(tryAsU32(x.kind));
-            if (x.kind === SafroleSealingKeysKind.Keys) {
-                e.sequenceFixLen(codecBandersnatchKey, x.keys);
-            }
-            else {
-                e.sequenceFixLen(Ticket.Codec, x.tickets);
-            }
-        }, (d) => {
-            const epochLength = context.epochLength;
-            const kind = d.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
-                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
-                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        }, (s) => {
-            const kind = s.decoder.varU32();
-            if (kind === SafroleSealingKeysKind.Keys) {
-                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
-                return;
-            }
-            if (kind === SafroleSealingKeysKind.Tickets) {
-                s.sequenceFixLen(Ticket.Codec, context.epochLength);
-                return;
-            }
-            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
-        });
-    });
-    static keys(keys) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
-    }
-    static tickets(tickets) {
-        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
-    }
-    constructor(kind, keys, tickets) {
-        super();
-        this.kind = kind;
-        this.keys = keys;
-        this.tickets = tickets;
-    }
-}
-class SafroleData {
-    nextValidatorData;
-    epochRoot;
-    sealingKeySeries;
-    ticketsAccumulator;
-    static Codec = codec$1.Class(SafroleData, {
-        nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: codec$1.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
-        sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: readonlyArray(codec$1.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
-    });
-    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
-        return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
-    }
-    constructor(
-    /** gamma_k */
-    nextValidatorData, 
-    /** gamma_z */
-    epochRoot, 
-    /** gamma_s */
-    sealingKeySeries, 
-    /** gamma_a */
-    ticketsAccumulator) {
-        this.nextValidatorData = nextValidatorData;
-        this.epochRoot = epochRoot;
-        this.sealingKeySeries = sealingKeySeries;
-        this.ticketsAccumulator = ticketsAccumulator;
-    }
-}
-
-/**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-const BASE_SERVICE_BALANCE = 100n;
-/**
- * `B_I`: The additional minimum balance required per item of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445000445000?v=0.6.7
- */
-const ELECTIVE_ITEM_BALANCE = 10n;
-/**
- * `B_L`: The additional minimum balance required per octet of elective service state.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445400445400?v=0.6.7
- */
-const ELECTIVE_BYTE_BALANCE = 1n;
-const zeroSizeHint = {
-    bytes: 0,
-    isExact: true,
-};
-/** 0-byte read, return given default value */
-const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
-/** Encode and decode object with leading version number. */
-const codecWithVersion = (val) => Descriptor.new("withVersion", {
-    bytes: val.sizeHint.bytes + 8,
-    isExact: false,
-}, (e, v) => {
-    e.varU64(0n);
-    val.encode(e, v);
-}, (d) => {
-    const version = d.varU64();
-    if (version !== 0n) {
-        throw new Error("Non-zero version is not supported!");
-    }
-    return val.decode(d);
-}, (s) => {
-    s.varU64();
-    val.skip(s);
-});
-/**
- * Service account details.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
- */
-class ServiceAccountInfo extends WithDebug {
-    codeHash;
-    balance;
-    accumulateMinGas;
-    onTransferMinGas;
-    storageUtilisationBytes;
-    gratisStorage;
-    storageUtilisationCount;
-    created;
-    lastAccumulation;
-    parentService;
-    static Codec = codec$1.Class(ServiceAccountInfo, {
-        codeHash: codec$1.bytes(HASH_SIZE).asOpaque(),
-        balance: codec$1.u64,
-        accumulateMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: codec$1.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: codec$1.u64,
-        gratisStorage: codec$1.u64,
-        storageUtilisationCount: codec$1.u32,
-        created: codec$1.u32.convert((x) => x, tryAsTimeSlot),
-        lastAccumulation: codec$1.u32.convert((x) => x, tryAsTimeSlot),
-        parentService: codec$1.u32.convert((x) => x, tryAsServiceId),
-    });
-    static create(a) {
-        return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
+    static create(a) {
+        return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
     }
     /**
      * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
@@ -8635,394 +8350,329 @@ class LookupHistoryItem {
     }
 }
 
-const codecServiceId = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
-    ? codec$1.u32.asOpaque()
-    : codec$1.varU32.convert((s) => tryAsU32(s), (i) => tryAsServiceId(i));
-/**
- * Activity Record of a single validator.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
- */
-class ValidatorStatistics {
-    blocks;
-    tickets;
-    preImages;
-    preImagesSize;
-    guarantees;
-    assurances;
-    static Codec = codec$1.Class(ValidatorStatistics, {
-        blocks: codec$1.u32,
-        tickets: codec$1.u32,
-        preImages: codec$1.u32,
-        preImagesSize: codec$1.u32,
-        guarantees: codec$1.u32,
-        assurances: codec$1.u32,
+/** Dictionary entry of services that auto-accumulate every block. */
+class AutoAccumulate {
+    service;
+    gasLimit;
+    static Codec = codec$1.Class(AutoAccumulate, {
+        service: codec$1.u32.asOpaque(),
+        gasLimit: codec$1.u64.asOpaque(),
     });
-    static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
-        return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
+    static create({ service, gasLimit }) {
+        return new AutoAccumulate(service, gasLimit);
     }
     constructor(
-    /** The number of blocks produced by the validator. */
-    blocks, 
-    /** The number of tickets introduced by the validator. */
-    tickets, 
-    /** The number of preimages introduced by the validator. */
-    preImages, 
-    /** The total number of octets across all preimages introduced by the validator. */
-    preImagesSize, 
-    /** The number of reports guaranteed by the validator. */
-    guarantees, 
-    /** The number of availability assurances made by the validator. */
-    assurances) {
-        this.blocks = blocks;
-        this.tickets = tickets;
-        this.preImages = preImages;
-        this.preImagesSize = preImagesSize;
-        this.guarantees = guarantees;
-        this.assurances = assurances;
-    }
-    static empty() {
-        const zero = tryAsU32(0);
-        return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
+    /** Service id that auto-accumulates. */
+    service, 
+    /** Gas limit for auto-accumulation. */
+    gasLimit) {
+        this.service = service;
+        this.gasLimit = gasLimit;
     }
 }
-const codecVarU16 = codec$1.varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
-/** Encode/decode unsigned gas. */
-const codecVarGas = codec$1.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
- * Single core statistics.
- * Updated per block, based on incoming work reports (`w`).
- *
- * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
- * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
-class CoreStatistics {
-    dataAvailabilityLoad;
-    popularity;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    bundleSize;
-    gasUsed;
-    static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? codec$1.Class(CoreStatistics, {
-            dataAvailabilityLoad: codec$1.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            extrinsicCount: codecVarU16,
-            extrinsicSize: codec$1.varU32,
-            exports: codecVarU16,
-            bundleSize: codec$1.varU32,
-            gasUsed: codecVarGas,
-        })
-        : codec$1.Class(CoreStatistics, {
-            dataAvailabilityLoad: codec$1.varU32,
-            popularity: codecVarU16,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: codec$1.varU32,
-            extrinsicCount: codecVarU16,
-            bundleSize: codec$1.varU32,
-            gasUsed: codecVarGas,
-        });
-    static create(v) {
-        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
+class PrivilegedServices {
+    manager;
+    delegator;
+    registrar;
+    assigners;
+    autoAccumulateServices;
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
+    static Codec = codec$1.Class(PrivilegedServices, {
+        manager: codec$1.u32.asOpaque(),
+        assigners: codecPerCore(codec$1.u32.asOpaque()),
+        delegator: codec$1.u32.asOpaque(),
+        registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+            ? codec$1.u32.asOpaque()
+            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
+        autoAccumulateServices: readonlyArray(codec$1.sequenceVarLen(AutoAccumulate.Codec)),
+    });
+    static create(a) {
+        return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
     }
     constructor(
-    /** `d` */
-    dataAvailabilityLoad, 
-    /** `p` */
-    popularity, 
-    /** `i` */
-    imports, 
-    /** `e` */
-    exports, 
-    /** `z` */
-    extrinsicSize, 
-    /** `x` */
-    extrinsicCount, 
-    /** `b` */
-    bundleSize, 
-    /** `u` */
-    gasUsed) {
-        this.dataAvailabilityLoad = dataAvailabilityLoad;
-        this.popularity = popularity;
-        this.imports = imports;
-        this.exports = exports;
-        this.extrinsicSize = extrinsicSize;
-        this.extrinsicCount = extrinsicCount;
-        this.bundleSize = bundleSize;
-        this.gasUsed = gasUsed;
-    }
-    static empty() {
-        const zero = tryAsU32(0);
-        const zero16 = tryAsU16(0);
-        const zeroGas = tryAsServiceGas(0);
-        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
+    /**
+     * `χ_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;
     }
 }
+
 /**
- * Service statistics.
- * Updated per block, based on available work reports (`W`).
+ * `H = 8`: The size of recent history, in blocks.
  *
- * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
  */
-class ServiceStatistics {
-    providedCount;
-    providedSize;
-    refinementCount;
-    refinementGasUsed;
-    imports;
-    exports;
-    extrinsicSize;
-    extrinsicCount;
-    accumulateCount;
-    accumulateGasUsed;
-    onTransfersCount;
-    onTransfersGasUsed;
-    static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: codec$1.Class(ServiceStatistics, {
-            providedCount: codecVarU16,
-            providedSize: codec$1.varU32,
-            refinementCount: codec$1.varU32,
-            refinementGasUsed: codecVarGas,
-            imports: codecVarU16,
-            exports: codecVarU16,
-            extrinsicSize: codec$1.varU32,
-            extrinsicCount: codecVarU16,
-            accumulateCount: codec$1.varU32,
-            accumulateGasUsed: codecVarGas,
-            onTransfersCount: codec$1.varU32,
-            onTransfersGasUsed: codecVarGas,
-        }),
-        versions: {
-            [GpVersion.V0_7_0]: codec$1.Class(ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: codec$1.varU32,
-                refinementCount: codec$1.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: codec$1.varU32,
-                exports: codecVarU16,
-                accumulateCount: codec$1.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: codec$1.varU32,
-                onTransfersGasUsed: codecVarGas,
-            }),
-            [GpVersion.V0_7_1]: codec$1.Class(ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: codec$1.varU32,
-                refinementCount: codec$1.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: codec$1.varU32,
-                exports: codecVarU16,
-                accumulateCount: codec$1.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: ignoreValueWithDefault(tryAsU32(0)),
-                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
-            }),
-        },
+const MAX_RECENT_HISTORY = 8;
+/** Recent history of a single block. */
+class BlockState extends WithDebug {
+    headerHash;
+    accumulationResult;
+    postStateRoot;
+    reported;
+    static Codec = codec$1.Class(BlockState, {
+        headerHash: codec$1.bytes(HASH_SIZE).asOpaque(),
+        accumulationResult: codec$1.bytes(HASH_SIZE),
+        postStateRoot: codec$1.bytes(HASH_SIZE).asOpaque(),
+        reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
-    static create(v) {
-        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
+    static create({ headerHash, accumulationResult, postStateRoot, reported }) {
+        return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
     }
     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 = tryAsU32(0);
-        const zero16 = tryAsU16(0);
-        const zeroGas = tryAsServiceGas(0);
-        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
+    /** 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;
     }
 }
-/** `pi`: Statistics of each validator, cores statistics and services statistics. */
-class StatisticsData {
-    current;
-    previous;
-    cores;
-    services;
-    static Codec = codec$1.Class(StatisticsData, {
-        current: codecPerValidator(ValidatorStatistics.Codec),
-        previous: codecPerValidator(ValidatorStatistics.Codec),
-        cores: codecPerCore(CoreStatistics.Codec),
-        services: codec$1.dictionary(codecServiceId, ServiceStatistics.Codec, {
-            sortKeys: (a, b) => a - b,
+class RecentBlocks extends WithDebug {
+    blocks;
+    accumulationLog;
+    static Codec = codec$1.Class(RecentBlocks, {
+        blocks: codecKnownSizeArray(BlockState.Codec, {
+            minLength: 0,
+            maxLength: MAX_RECENT_HISTORY,
+            typicalLength: MAX_RECENT_HISTORY,
+        }),
+        accumulationLog: codec$1.object({
+            peaks: readonlyArray(codec$1.sequenceVarLen(codec$1.optional(codec$1.bytes(HASH_SIZE)))),
         }),
     });
-    static create(v) {
-        return new StatisticsData(v.current, v.previous, v.cores, v.services);
+    static create(a) {
+        return new RecentBlocks(a.blocks, a.accumulationLog);
     }
-    constructor(current, previous, cores, services) {
-        this.current = current;
-        this.previous = previous;
-        this.cores = cores;
-        this.services = services;
+    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;
     }
 }
-
-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);
+/**
+ * Recent history of blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
+ */
+class RecentBlocksHistory extends WithDebug {
+    current;
+    static Codec = Descriptor.new("RecentBlocksHistory", RecentBlocks.Codec.sizeHint, (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()), (decoder) => {
+        const recentBlocks = RecentBlocks.Codec.decode(decoder);
+        return RecentBlocksHistory.create(recentBlocks);
+    }, (skip) => {
+        return RecentBlocks.Codec.skip(skip);
+    });
+    static create(recentBlocks) {
+        return new RecentBlocksHistory(recentBlocks);
     }
-    authPoolsView() {
-        return reencodeAsView(authPoolsCodec, this.state.authPools, this.chainSpec);
+    static empty() {
+        return RecentBlocksHistory.create(RecentBlocks.create({
+            blocks: asKnownSize([]),
+            accumulationLog: { peaks: [] },
+        }));
     }
-    authQueuesView() {
-        return reencodeAsView(authQueuesCodec, this.state.authQueues, this.chainSpec);
+    /**
+     * Returns the block's BEEFY super peak.
+     */
+    static accumulationResult(block) {
+        return block.accumulationResult;
     }
-    recentBlocksView() {
-        return reencodeAsView(RecentBlocks.Codec, this.state.recentBlocks, this.chainSpec);
+    constructor(current) {
+        super();
+        this.current = current;
     }
-    statisticsView() {
-        return reencodeAsView(StatisticsData.Codec, this.state.statistics, this.chainSpec);
+    /** 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");
     }
-    accumulationQueueView() {
-        return reencodeAsView(accumulationQueueCodec, this.state.accumulationQueue, this.chainSpec);
+    asCurrent() {
+        if (this.current === null) {
+            throw new Error("Cannot access current RecentBlocks format");
+        }
+        return this.current;
     }
-    recentlyAccumulatedView() {
-        return reencodeAsView(recentlyAccumulatedCodec, this.state.recentlyAccumulated, this.chainSpec);
+    updateBlocks(blocks) {
+        if (this.current !== null) {
+            return RecentBlocksHistory.create(RecentBlocks.create({
+                ...this.current,
+                blocks: asOpaqueType(blocks),
+            }));
+        }
+        throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
     }
-    safroleDataView() {
-        // TODO [ToDr] Consider exposting `safrole` from state
-        // instead of individual fields
-        const safrole = SafroleData.create({
-            nextValidatorData: this.state.nextValidatorData,
-            epochRoot: this.state.epochRoot,
-            sealingKeySeries: this.state.sealingKeySeries,
-            ticketsAccumulator: this.state.ticketsAccumulator,
-        });
-        return reencodeAsView(SafroleData.Codec, safrole, this.chainSpec);
+}
+
+/**
+ * Fixed size of validator metadata.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
+ */
+const VALIDATOR_META_BYTES = 128;
+/**
+ * Details about validators' identity.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
+ */
+class ValidatorData extends WithDebug {
+    bandersnatch;
+    ed25519;
+    bls;
+    metadata;
+    static Codec = codec$1.Class(ValidatorData, {
+        bandersnatch: codec$1.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: codec$1.bytes(ED25519_KEY_BYTES).asOpaque(),
+        bls: codec$1.bytes(BLS_KEY_BYTES).asOpaque(),
+        metadata: codec$1.bytes(VALIDATOR_META_BYTES),
+    });
+    static create({ ed25519, bandersnatch, bls, metadata }) {
+        return new ValidatorData(bandersnatch, ed25519, bls, metadata);
     }
-    getServiceInfoView(id) {
-        const service = this.state.getService(id);
-        if (service === null) {
-            return null;
-        }
-        return reencodeAsView(ServiceAccountInfo.Codec, service.getInfo(), this.chainSpec);
+    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;
     }
 }
 
-/** Dictionary entry of services that auto-accumulate every block. */
-class AutoAccumulate {
-    service;
-    gasLimit;
-    static Codec = codec$1.Class(AutoAccumulate, {
-        service: codec$1.u32.asOpaque(),
-        gasLimit: codec$1.u64.asOpaque(),
+var SafroleSealingKeysKind;
+(function (SafroleSealingKeysKind) {
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
+    SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
+})(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
+const codecBandersnatchKey = codec$1.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+class SafroleSealingKeysData extends WithDebug {
+    kind;
+    keys;
+    tickets;
+    static Codec = codecWithContext((context) => {
+        return codec$1.custom({
+            name: "SafroleSealingKeys",
+            sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
+        }, (e, x) => {
+            e.varU32(tryAsU32(x.kind));
+            if (x.kind === SafroleSealingKeysKind.Keys) {
+                e.sequenceFixLen(codecBandersnatchKey, x.keys);
+            }
+            else {
+                e.sequenceFixLen(Ticket.Codec, x.tickets);
+            }
+        }, (d) => {
+            const epochLength = context.epochLength;
+            const kind = d.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
+                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        }, (s) => {
+            const kind = s.decoder.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
+                return;
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                s.sequenceFixLen(Ticket.Codec, context.epochLength);
+                return;
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        });
     });
-    static create({ service, gasLimit }) {
-        return new AutoAccumulate(service, gasLimit);
+    static keys(keys) {
+        return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined);
     }
-    constructor(
-    /** Service id that auto-accumulates. */
-    service, 
-    /** Gas limit for auto-accumulation. */
-    gasLimit) {
-        this.service = service;
-        this.gasLimit = gasLimit;
+    static tickets(tickets) {
+        return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets);
+    }
+    constructor(kind, keys, tickets) {
+        super();
+        this.kind = kind;
+        this.keys = keys;
+        this.tickets = tickets;
     }
 }
-/**
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
- */
-class PrivilegedServices {
-    manager;
-    delegator;
-    registrar;
-    assigners;
-    autoAccumulateServices;
-    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = codec$1.Class(PrivilegedServices, {
-        manager: codec$1.u32.asOpaque(),
-        assigners: codecPerCore(codec$1.u32.asOpaque()),
-        delegator: codec$1.u32.asOpaque(),
-        registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? codec$1.u32.asOpaque()
-            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: readonlyArray(codec$1.sequenceVarLen(AutoAccumulate.Codec)),
+class SafroleData {
+    nextValidatorData;
+    epochRoot;
+    sealingKeySeries;
+    ticketsAccumulator;
+    static Codec = codec$1.Class(SafroleData, {
+        nextValidatorData: codecPerValidator(ValidatorData.Codec),
+        epochRoot: codec$1.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        sealingKeySeries: SafroleSealingKeysData.Codec,
+        ticketsAccumulator: readonlyArray(codec$1.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
     });
-    static create(a) {
-        return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+    static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
+        return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
     }
     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;
+    /** gamma_k */
+    nextValidatorData, 
+    /** gamma_z */
+    epochRoot, 
+    /** gamma_s */
+    sealingKeySeries, 
+    /** gamma_a */
+    ticketsAccumulator) {
+        this.nextValidatorData = nextValidatorData;
+        this.epochRoot = epochRoot;
+        this.sealingKeySeries = sealingKeySeries;
+        this.ticketsAccumulator = ticketsAccumulator;
     }
 }
 
@@ -9135,51 +8785,316 @@ class UpdateService {
             account: serviceInfo,
         });
     }
-    static create({ serviceId, serviceInfo, lookupHistory, }) {
-        return new UpdateService(serviceId, {
-            kind: UpdateServiceKind.Create,
-            account: serviceInfo,
-            lookupHistory,
-        });
+    static create({ serviceId, serviceInfo, lookupHistory, }) {
+        return new UpdateService(serviceId, {
+            kind: UpdateServiceKind.Create,
+            account: serviceInfo,
+            lookupHistory,
+        });
+    }
+}
+/** Update service storage kind. */
+var UpdateStorageKind;
+(function (UpdateStorageKind) {
+    /** Set a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
+    /** Remove a storage value. */
+    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
+})(UpdateStorageKind || (UpdateStorageKind = {}));
+/**
+ * Update service storage item.
+ *
+ * Can either create/modify an entry or remove it.
+ */
+class UpdateStorage {
+    serviceId;
+    action;
+    constructor(serviceId, action) {
+        this.serviceId = serviceId;
+        this.action = action;
+    }
+    static set({ serviceId, storage }) {
+        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Set, storage });
+    }
+    static remove({ serviceId, key }) {
+        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
+    }
+    get key() {
+        if (this.action.kind === UpdateStorageKind.Remove) {
+            return this.action.key;
+        }
+        return this.action.storage.key;
+    }
+    get value() {
+        if (this.action.kind === UpdateStorageKind.Remove) {
+            return null;
+        }
+        return this.action.storage.value;
+    }
+}
+
+const codecServiceId = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isSuite(TestSuite.JAMDUNA, GpVersion.V0_6_7)
+    ? codec$1.u32.asOpaque()
+    : codec$1.varU32.convert((s) => tryAsU32(s), (i) => tryAsServiceId(i));
+/**
+ * Activity Record of a single validator.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/183701183701
+ */
+class ValidatorStatistics {
+    blocks;
+    tickets;
+    preImages;
+    preImagesSize;
+    guarantees;
+    assurances;
+    static Codec = codec$1.Class(ValidatorStatistics, {
+        blocks: codec$1.u32,
+        tickets: codec$1.u32,
+        preImages: codec$1.u32,
+        preImagesSize: codec$1.u32,
+        guarantees: codec$1.u32,
+        assurances: codec$1.u32,
+    });
+    static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
+        return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
+    }
+    constructor(
+    /** The number of blocks produced by the validator. */
+    blocks, 
+    /** The number of tickets introduced by the validator. */
+    tickets, 
+    /** The number of preimages introduced by the validator. */
+    preImages, 
+    /** The total number of octets across all preimages introduced by the validator. */
+    preImagesSize, 
+    /** The number of reports guaranteed by the validator. */
+    guarantees, 
+    /** The number of availability assurances made by the validator. */
+    assurances) {
+        this.blocks = blocks;
+        this.tickets = tickets;
+        this.preImages = preImages;
+        this.preImagesSize = preImagesSize;
+        this.guarantees = guarantees;
+        this.assurances = assurances;
+    }
+    static empty() {
+        const zero = tryAsU32(0);
+        return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
+    }
+}
+const codecVarU16 = codec$1.varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
+/** Encode/decode unsigned gas. */
+const codecVarGas = codec$1.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
+/**
+ * Single core statistics.
+ * Updated per block, based on incoming work reports (`w`).
+ *
+ * https://graypaper.fluffylabs.dev/#/68eaa1f/18f10318f103?v=0.6.4
+ * https://github.com/gavofyork/graypaper/blob/9bffb08f3ea7b67832019176754df4fb36b9557d/text/statistics.tex#L65
+ */
+class CoreStatistics {
+    dataAvailabilityLoad;
+    popularity;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    bundleSize;
+    gasUsed;
+    static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
+        ? codec$1.Class(CoreStatistics, {
+            dataAvailabilityLoad: codec$1.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            extrinsicCount: codecVarU16,
+            extrinsicSize: codec$1.varU32,
+            exports: codecVarU16,
+            bundleSize: codec$1.varU32,
+            gasUsed: codecVarGas,
+        })
+        : codec$1.Class(CoreStatistics, {
+            dataAvailabilityLoad: codec$1.varU32,
+            popularity: codecVarU16,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: codec$1.varU32,
+            extrinsicCount: codecVarU16,
+            bundleSize: codec$1.varU32,
+            gasUsed: codecVarGas,
+        });
+    static create(v) {
+        return new CoreStatistics(v.dataAvailabilityLoad, v.popularity, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.bundleSize, v.gasUsed);
+    }
+    constructor(
+    /** `d` */
+    dataAvailabilityLoad, 
+    /** `p` */
+    popularity, 
+    /** `i` */
+    imports, 
+    /** `e` */
+    exports, 
+    /** `z` */
+    extrinsicSize, 
+    /** `x` */
+    extrinsicCount, 
+    /** `b` */
+    bundleSize, 
+    /** `u` */
+    gasUsed) {
+        this.dataAvailabilityLoad = dataAvailabilityLoad;
+        this.popularity = popularity;
+        this.imports = imports;
+        this.exports = exports;
+        this.extrinsicSize = extrinsicSize;
+        this.extrinsicCount = extrinsicCount;
+        this.bundleSize = bundleSize;
+        this.gasUsed = gasUsed;
+    }
+    static empty() {
+        const zero = tryAsU32(0);
+        const zero16 = tryAsU16(0);
+        const zeroGas = tryAsServiceGas(0);
+        return new CoreStatistics(zero, zero16, zero16, zero16, zero, zero16, zero, zeroGas);
     }
 }
-/** Update service storage kind. */
-var UpdateStorageKind;
-(function (UpdateStorageKind) {
-    /** Set a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Set"] = 0] = "Set";
-    /** Remove a storage value. */
-    UpdateStorageKind[UpdateStorageKind["Remove"] = 1] = "Remove";
-})(UpdateStorageKind || (UpdateStorageKind = {}));
 /**
- * Update service storage item.
+ * Service statistics.
+ * Updated per block, based on available work reports (`W`).
  *
- * Can either create/modify an entry or remove it.
+ * https://graypaper.fluffylabs.dev/#/1c979cb/199802199802?v=0.7.1
  */
-class UpdateStorage {
-    serviceId;
-    action;
-    constructor(serviceId, action) {
-        this.serviceId = serviceId;
-        this.action = action;
+class ServiceStatistics {
+    providedCount;
+    providedSize;
+    refinementCount;
+    refinementGasUsed;
+    imports;
+    exports;
+    extrinsicSize;
+    extrinsicCount;
+    accumulateCount;
+    accumulateGasUsed;
+    onTransfersCount;
+    onTransfersGasUsed;
+    static Codec = Compatibility.selectIfGreaterOrEqual({
+        fallback: codec$1.Class(ServiceStatistics, {
+            providedCount: codecVarU16,
+            providedSize: codec$1.varU32,
+            refinementCount: codec$1.varU32,
+            refinementGasUsed: codecVarGas,
+            imports: codecVarU16,
+            exports: codecVarU16,
+            extrinsicSize: codec$1.varU32,
+            extrinsicCount: codecVarU16,
+            accumulateCount: codec$1.varU32,
+            accumulateGasUsed: codecVarGas,
+            onTransfersCount: codec$1.varU32,
+            onTransfersGasUsed: codecVarGas,
+        }),
+        versions: {
+            [GpVersion.V0_7_0]: codec$1.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: codec$1.varU32,
+                refinementCount: codec$1.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: codec$1.varU32,
+                exports: codecVarU16,
+                accumulateCount: codec$1.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: codec$1.varU32,
+                onTransfersGasUsed: codecVarGas,
+            }),
+            [GpVersion.V0_7_1]: codec$1.Class(ServiceStatistics, {
+                providedCount: codecVarU16,
+                providedSize: codec$1.varU32,
+                refinementCount: codec$1.varU32,
+                refinementGasUsed: codecVarGas,
+                imports: codecVarU16,
+                extrinsicCount: codecVarU16,
+                extrinsicSize: codec$1.varU32,
+                exports: codecVarU16,
+                accumulateCount: codec$1.varU32,
+                accumulateGasUsed: codecVarGas,
+                onTransfersCount: ignoreValueWithDefault(tryAsU32(0)),
+                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
+            }),
+        },
+    });
+    static create(v) {
+        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
     }
-    static set({ serviceId, storage }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Set, storage });
+    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 remove({ serviceId, key }) {
-        return new UpdateStorage(serviceId, { kind: UpdateStorageKind.Remove, key });
+    static empty() {
+        const zero = tryAsU32(0);
+        const zero16 = tryAsU16(0);
+        const zeroGas = tryAsServiceGas(0);
+        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
     }
-    get key() {
-        if (this.action.kind === UpdateStorageKind.Remove) {
-            return this.action.key;
-        }
-        return this.action.storage.key;
+}
+/** `pi`: Statistics of each validator, cores statistics and services statistics. */
+class StatisticsData {
+    current;
+    previous;
+    cores;
+    services;
+    static Codec = codec$1.Class(StatisticsData, {
+        current: codecPerValidator(ValidatorStatistics.Codec),
+        previous: codecPerValidator(ValidatorStatistics.Codec),
+        cores: codecPerCore(CoreStatistics.Codec),
+        services: codec$1.dictionary(codecServiceId, ServiceStatistics.Codec, {
+            sortKeys: (a, b) => a - b,
+        }),
+    });
+    static create(v) {
+        return new StatisticsData(v.current, v.previous, v.cores, v.services);
     }
-    get value() {
-        if (this.action.kind === UpdateStorageKind.Remove) {
-            return null;
-        }
-        return this.action.storage.value;
+    constructor(current, previous, cores, services) {
+        this.current = current;
+        this.previous = previous;
+        this.cores = cores;
+        this.services = services;
     }
 }
 
@@ -9282,10 +9197,9 @@ class InMemoryService extends WithDebug {
  * A special version of state, stored fully in-memory.
  */
 class InMemoryState extends WithDebug {
-    chainSpec;
     /** Create a new `InMemoryState` by providing all required fields. */
-    static new(chainSpec, state) {
-        return new InMemoryState(chainSpec, state);
+    static create(state) {
+        return new InMemoryState(state);
     }
     /**
      * Create a new `InMemoryState` with a partial state override.
@@ -9301,7 +9215,7 @@ class InMemoryState extends WithDebug {
     /**
      * Create a new `InMemoryState` from some other state object.
      */
-    static copyFrom(chainSpec, other, servicesData) {
+    static copyFrom(other, servicesData) {
         const services = new Map();
         for (const [id, entries] of servicesData.entries()) {
             const service = other.getService(id);
@@ -9311,7 +9225,7 @@ class InMemoryState extends WithDebug {
             const inMemService = InMemoryService.copyFrom(service, entries);
             services.set(id, inMemService);
         }
-        return InMemoryState.new(chainSpec, {
+        return InMemoryState.create({
             availabilityAssignment: other.availabilityAssignment,
             accumulationQueue: other.accumulationQueue,
             designatedValidatorData: other.designatedValidatorData,
@@ -9508,9 +9422,8 @@ class InMemoryState extends WithDebug {
     getService(id) {
         return this.services.get(id) ?? null;
     }
-    constructor(chainSpec, s) {
+    constructor(s) {
         super();
-        this.chainSpec = chainSpec;
         this.availabilityAssignment = s.availabilityAssignment;
         this.designatedValidatorData = s.designatedValidatorData;
         this.nextValidatorData = s.nextValidatorData;
@@ -9532,14 +9445,11 @@ class InMemoryState extends WithDebug {
         this.accumulationOutputLog = s.accumulationOutputLog;
         this.services = s.services;
     }
-    view() {
-        return new InMemoryStateView(this.chainSpec, this);
-    }
     /**
      * Create an empty and possibly incoherent `InMemoryState`.
      */
     static empty(spec) {
-        return new InMemoryState(spec, {
+        return new InMemoryState({
             availabilityAssignment: tryAsPerCore(Array.from({ length: spec.coresCount }, () => null), spec),
             designatedValidatorData: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorData.create({
                 bandersnatch: Bytes.zero(BANDERSNATCH_KEY_BYTES).asOpaque(),
@@ -9575,7 +9485,7 @@ class InMemoryState extends WithDebug {
             entropy: FixedSizeArray.fill(() => Bytes.zero(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
             authPools: tryAsPerCore(Array.from({ length: spec.coresCount }, () => asKnownSize([])), spec),
             authQueues: tryAsPerCore(Array.from({ length: spec.coresCount }, () => FixedSizeArray.fill(() => Bytes.zero(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE)), spec),
-            recentBlocks: RecentBlocks.empty(),
+            recentBlocks: RecentBlocksHistory.empty(),
             statistics: StatisticsData.create({
                 current: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()), spec),
                 previous: tryAsPerValidator(Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()), spec),
@@ -9613,7 +9523,6 @@ const serviceDataCodec = codec$1.dictionary(codec$1.u32.asOpaque(), serviceEntri
 
 var index$g = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  AUTHORIZATION_QUEUE_SIZE: AUTHORIZATION_QUEUE_SIZE,
   AccumulationOutput: AccumulationOutput,
   AutoAccumulate: AutoAccumulate,
   AvailabilityAssignment: AvailabilityAssignment,
@@ -9627,12 +9536,11 @@ var index$g = /*#__PURE__*/Object.freeze({
   InMemoryService: InMemoryService,
   InMemoryState: InMemoryState,
   LookupHistoryItem: LookupHistoryItem,
-  MAX_AUTH_POOL_SIZE: MAX_AUTH_POOL_SIZE,
   MAX_RECENT_HISTORY: MAX_RECENT_HISTORY,
-  NotYetAccumulatedReport: NotYetAccumulatedReport,
   PreimageItem: PreimageItem,
   PrivilegedServices: PrivilegedServices,
   RecentBlocks: RecentBlocks,
+  RecentBlocksHistory: RecentBlocksHistory,
   SafroleData: SafroleData,
   SafroleSealingKeysData: SafroleSealingKeysData,
   get SafroleSealingKeysKind () { return SafroleSealingKeysKind; },
@@ -9651,35 +9559,71 @@ var index$g = /*#__PURE__*/Object.freeze({
   ValidatorData: ValidatorData,
   ValidatorStatistics: ValidatorStatistics,
   accumulationOutputComparator: accumulationOutputComparator,
-  accumulationQueueCodec: accumulationQueueCodec,
-  authPoolsCodec: authPoolsCodec,
-  authQueuesCodec: authQueuesCodec,
-  availabilityAssignmentsCodec: availabilityAssignmentsCodec,
   codecPerCore: codecPerCore,
   codecWithVersion: codecWithVersion,
   hashComparator: hashComparator,
   ignoreValueWithDefault: ignoreValueWithDefault,
-  recentlyAccumulatedCodec: recentlyAccumulatedCodec,
   serviceDataCodec: serviceDataCodec,
   serviceEntriesCodec: serviceEntriesCodec,
   tryAsLookupHistorySlots: tryAsLookupHistorySlots,
-  tryAsPerCore: tryAsPerCore,
-  validatorsDataCodec: validatorsDataCodec
+  tryAsPerCore: tryAsPerCore
 });
 
+/**
+ * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
+ */
+class NotYetAccumulatedReport extends WithDebug {
+    report;
+    dependencies;
+    static Codec = codec$1.Class(NotYetAccumulatedReport, {
+        report: WorkReport.Codec,
+        dependencies: codecKnownSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), {
+            typicalLength: MAX_REPORT_DEPENDENCIES / 2,
+            maxLength: MAX_REPORT_DEPENDENCIES,
+            minLength: 0,
+        }),
+    });
+    static create({ report, dependencies }) {
+        return new NotYetAccumulatedReport(report, dependencies);
+    }
+    constructor(
+    /**
+     * Each of these were made available at most one epoch ago
+     * but have or had unfulfilled dependencies.
+     */
+    report, 
+    /**
+     * Alongside the work-report itself, we retain its un-accumulated
+     * dependencies, a set of work-package hashes.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
+     */
+    dependencies) {
+        super();
+        this.report = report;
+        this.dependencies = dependencies;
+    }
+}
+
 /** Serialization for particular state entries. */
 var serialize;
 (function (serialize) {
     /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
     serialize.authPools = {
         key: stateKeys.index(StateKeyIdx.Alpha),
-        Codec: authPoolsCodec,
+        Codec: codecPerCore(codecKnownSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), {
+            minLength: 0,
+            maxLength: MAX_AUTH_POOL_SIZE,
+            typicalLength: MAX_AUTH_POOL_SIZE,
+        })),
         extract: (s) => s.authPools,
     };
     /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
     serialize.authQueues = {
         key: stateKeys.index(StateKeyIdx.Phi),
-        Codec: authQueuesCodec,
+        Codec: codecPerCore(codecFixedSizeArray(codec$1.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE)),
         extract: (s) => s.authQueues,
     };
     /**
@@ -9688,7 +9632,7 @@ var serialize;
      */
     serialize.recentBlocks = {
         key: stateKeys.index(StateKeyIdx.Beta),
-        Codec: RecentBlocks.Codec,
+        Codec: RecentBlocksHistory.Codec,
         extract: (s) => s.recentBlocks,
     };
     /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
@@ -9717,25 +9661,25 @@ var serialize;
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
     serialize.designatedValidators = {
         key: stateKeys.index(StateKeyIdx.Iota),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(ValidatorData.Codec),
         extract: (s) => s.designatedValidatorData,
     };
     /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
     serialize.currentValidators = {
         key: stateKeys.index(StateKeyIdx.Kappa),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(ValidatorData.Codec),
         extract: (s) => s.currentValidatorData,
     };
     /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
     serialize.previousValidators = {
         key: stateKeys.index(StateKeyIdx.Lambda),
-        Codec: validatorsDataCodec,
+        Codec: codecPerValidator(ValidatorData.Codec),
         extract: (s) => s.previousValidatorData,
     };
     /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
     serialize.availabilityAssignment = {
         key: stateKeys.index(StateKeyIdx.Rho),
-        Codec: availabilityAssignmentsCodec,
+        Codec: codecPerCore(codec$1.optional(AvailabilityAssignment.Codec)),
         extract: (s) => s.availabilityAssignment,
     };
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
@@ -9759,13 +9703,13 @@ var serialize;
     /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
     serialize.accumulationQueue = {
         key: stateKeys.index(StateKeyIdx.Omega),
-        Codec: accumulationQueueCodec,
+        Codec: codecPerEpochBlock(readonlyArray(codec$1.sequenceVarLen(NotYetAccumulatedReport.Codec))),
         extract: (s) => s.accumulationQueue,
     };
     /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
     serialize.recentlyAccumulated = {
         key: stateKeys.index(StateKeyIdx.Xi),
-        Codec: recentlyAccumulatedCodec,
+        Codec: codecPerEpochBlock(codec$1.sequenceVarLen(codec$1.bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x))),
         extract: (s) => s.recentlyAccumulated,
     };
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
@@ -9806,84 +9750,6 @@ var serialize;
  */
 const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(Bytes.fromBlob(v.raw, v.raw.length)), (d) => BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
 
-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.fromBytesBlob(bytes);
-        d.attachContext(this.spec);
-        const view = Codec.View.decode(d);
-        this.viewCache.set(key, view);
-        return view;
-    }
-    availabilityAssignmentView() {
-        return this.retrieveView(serialize.availabilityAssignment, "availabilityAssignmentView");
-    }
-    designatedValidatorDataView() {
-        return this.retrieveView(serialize.designatedValidators, "designatedValidatorsView");
-    }
-    currentValidatorDataView() {
-        return this.retrieveView(serialize.currentValidators, "currentValidatorsView");
-    }
-    previousValidatorDataView() {
-        return this.retrieveView(serialize.previousValidators, "previousValidatorsView");
-    }
-    authPoolsView() {
-        return this.retrieveView(serialize.authPools, "authPoolsView");
-    }
-    authQueuesView() {
-        return this.retrieveView(serialize.authQueues, "authQueuesView");
-    }
-    recentBlocksView() {
-        return this.retrieveView(serialize.recentBlocks, "recentBlocksView");
-    }
-    statisticsView() {
-        return this.retrieveView(serialize.statistics, "statisticsView");
-    }
-    accumulationQueueView() {
-        return this.retrieveView(serialize.accumulationQueue, "accumulationQueueView");
-    }
-    recentlyAccumulatedView() {
-        return this.retrieveView(serialize.recentlyAccumulated, "recentlyAccumulatedView");
-    }
-    safroleDataView() {
-        return this.retrieveView(serialize.safrole, "safroleDataView");
-    }
-    getServiceInfoView(id) {
-        const serviceData = serialize.serviceData(id);
-        const bytes = this.backend.get(serviceData.key);
-        if (bytes === null) {
-            return null;
-        }
-        if (!this.recentlyUsedServices.includes(id)) {
-            this.recentlyUsedServices.push(id);
-        }
-        return Decoder.decodeObject(serviceData.Codec.View, bytes, this.spec);
-    }
-}
-
 /**
  * State object which reads it's entries from some backend.
  *
@@ -9896,7 +9762,7 @@ class SerializedState {
     spec;
     blake2b;
     backend;
-    recentlyUsedServices;
+    _recentServiceIds;
     /** Create a state-like object from collection of serialized entries. */
     static fromStateEntries(spec, blake2b, state, recentServices = []) {
         return new SerializedState(spec, blake2b, state, recentServices);
@@ -9905,63 +9771,49 @@ class SerializedState {
     static new(spec, blake2b, db, recentServices = []) {
         return new SerializedState(spec, blake2b, db, recentServices);
     }
-    dataCache = HashDictionary.new();
-    viewCache = HashDictionary.new();
     constructor(spec, blake2b, backend, 
     /** Best-effort list of recently active services. */
-    recentlyUsedServices) {
+    _recentServiceIds) {
         this.spec = spec;
         this.blake2b = blake2b;
         this.backend = backend;
-        this.recentlyUsedServices = recentlyUsedServices;
+        this._recentServiceIds = _recentServiceIds;
     }
     /** Comparing the serialized states, just means comparing their backends. */
     [TEST_COMPARE_USING]() {
         return this.backend;
     }
-    /** Return a non-decoding version of the state. */
-    view() {
-        return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
-    }
     // TODO [ToDr] Temporary method to update the state,
     // without changing references.
     updateBackend(newBackend) {
         this.backend = newBackend;
-        this.dataCache = HashDictionary.new();
-        this.viewCache = HashDictionary.new();
     }
     recentServiceIds() {
-        return this.recentlyUsedServices;
+        return this._recentServiceIds;
     }
     getService(id) {
         const serviceData = this.retrieveOptional(serialize.serviceData(id));
         if (serviceData === undefined) {
             return null;
         }
-        if (!this.recentlyUsedServices.includes(id)) {
-            this.recentlyUsedServices.push(id);
+        if (!this._recentServiceIds.includes(id)) {
+            this._recentServiceIds.push(id);
         }
         return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
     }
-    retrieve(k, description) {
-        const data = this.retrieveOptional(k);
-        if (data === undefined) {
-            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${k.key}`);
+    retrieve({ key, Codec }, description) {
+        const bytes = this.backend.get(key);
+        if (bytes === null) {
+            throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${key}`);
         }
-        return data;
+        return Decoder.decodeObject(Codec, bytes, this.spec);
     }
     retrieveOptional({ key, Codec }) {
-        const cached = this.dataCache.get(key);
-        if (cached !== undefined) {
-            return cached;
-        }
         const bytes = this.backend.get(key);
         if (bytes === null) {
             return undefined;
         }
-        const data = Decoder.decodeObject(Codec, bytes, this.spec);
-        this.dataCache.set(key, data);
-        return data;
+        return Decoder.decodeObject(Codec, bytes, this.spec);
     }
     get availabilityAssignment() {
         return this.retrieve(serialize.availabilityAssignment, "availabilityAssignment");
@@ -11039,7 +10891,6 @@ var index$e = /*#__PURE__*/Object.freeze({
   __proto__: null,
   SerializedService: SerializedService,
   SerializedState: SerializedState,
-  SerializedStateView: SerializedStateView,
   StateEntries: StateEntries,
   get StateEntryUpdateAction () { return StateEntryUpdateAction; },
   get StateKeyIdx () { return StateKeyIdx; },
@@ -11232,11 +11083,7 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const inMemoryStateCodec = (spec) => codec$1.Class(class State extends InMemoryState {
-    static create(data) {
-        return InMemoryState.new(spec, data);
-    }
-}, {
+const inMemoryStateCodec = codec$1.Class(InMemoryState, {
     // alpha
     authPools: serialize.authPools.Codec,
     // phi
@@ -11315,7 +11162,7 @@ class InMemoryStates {
     }
     /** Insert a full state into the database. */
     async insertState(headerHash, state) {
-        const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
+        const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
         this.db.set(headerHash, encoded);
         return Result$1.ok(OK);
     }
@@ -11324,7 +11171,7 @@ class InMemoryStates {
         if (encodedState === undefined) {
             return null;
         }
-        return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+        return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
     }
 }
 
@@ -17254,10 +17101,10 @@ const recentBlocksHistoryFromJson = json.object({
         peaks: json.array(json.nullable(fromJson.bytes32())),
     },
 }, ({ history, mmr }) => {
-    return RecentBlocks.create({
+    return RecentBlocksHistory.create(RecentBlocks.create({
         blocks: history,
         accumulationLog: mmr,
-    });
+    }));
 });
 
 const ticketFromJson = json.object({
@@ -17455,7 +17302,7 @@ const fullStateDumpFromJson = (spec) => json.object({
     if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && chi.chi_r === undefined) {
         throw new Error("Registrar is required in Privileges GP ^0.7.1");
     }
-    return InMemoryState.new(spec, {
+    return InMemoryState.create({
         authPools: tryAsPerCore(alpha.map((perCore) => {
             if (perCore.length > MAX_AUTH_POOL_SIZE) {
                 throw new Error(`AuthPools: expected less than ${MAX_AUTH_POOL_SIZE}, got ${perCore.length}`);
@@ -17468,7 +17315,7 @@ const fullStateDumpFromJson = (spec) => json.object({
             }
             return asKnownSize(perCore);
         }), spec),
-        recentBlocks: beta ?? RecentBlocks.empty(),
+        recentBlocks: beta ?? RecentBlocksHistory.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -17541,21 +17388,21 @@ class TransitionHasher {
      */
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-        const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
-        const countEncoded = Encoder.encodeObject(codec$1.varU32, guaranteesCount);
-        const guaranteesBlobs = extrinsicView.guarantees
+        const guarantees = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
-            .reduce((aggregated, guarantee) => {
+            .map((guarantee) => {
             const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque();
-            aggregated.push(reportHash.raw);
-            aggregated.push(guarantee.slot.encoded().raw);
-            aggregated.push(guarantee.credentials.encoded().raw);
-            return aggregated;
-        }, [countEncoded.raw]);
+            return BytesBlob.blobFromParts([
+                reportHash.raw,
+                guarantee.slot.encoded().raw,
+                guarantee.credentials.encoded().raw,
+            ]);
+        });
+        const guaranteeBlob = Encoder.encodeObject(codec$1.sequenceVarLen(dumpCodec), guarantees, this.context);
         const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque();
         const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque();
-        const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque();
+        const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque();
         const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque();
         const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque();
         const encoded = BytesBlob.blobFromParts([et.raw, ep.raw, eg.raw, ea.raw, ed.raw]);