@typeberry/lib 0.2.0-e767e74 → 0.2.0

package/index.d.ts

@@ -2427,15 +2427,11 @@ type ClassConstructor<T> = {
   create: (o: CodecRecord<T>) => T;
 };
 
-/** A full codec type, i.e. the `Encode` and `Decode`. */
+/**
+ * A full codec type, i.e. the `Encode` and `Decode`.
+ */
 type Codec<T> = Encode<T> & Decode<T>;
 
-/** A codec descriptor with extra view. */
-type CodecWithView<T, V> = Codec<T> & {
-  /** encoded data view codec. */
-  View: Codec<V>;
-};
-
 /**
  * Type descriptor definition.
  *
@@ -2444,7 +2440,7 @@ type CodecWithView<T, V> = Codec<T> & {
  *
  * Descriptors can be composed to form more complex typings.
  */
-declare class Descriptor<T, V = T> implements Codec<T>, Skip, CodecWithView<T, V> {
+declare class Descriptor<T, V = T> implements Codec<T>, Skip {
   /** A "lightweight" version of the object. */
   public readonly View: Descriptor<V>;
 
@@ -2690,10 +2686,6 @@ declare abstract class ObjectView<T> {
   toString() {
     return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
   }
-
-  [TEST_COMPARE_USING]() {
-    return this.materialize();
-  }
 }
 
 /**
@@ -3245,25 +3237,15 @@ declare namespace codec$1 {
       sizeHint: SizeHint;
     },
     chooser: (ctx: unknown | null) => Descriptor<T, V>,
-  ): Descriptor<T, V> => {
-    const Self = chooser(null);
-    return Descriptor.withView(
+  ): Descriptor<T, V> =>
+    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)
-        ? select(
-            {
-              name: Self.View.name,
-              sizeHint: Self.View.sizeHint,
-            },
-            (ctx) => chooser(ctx).View,
-          )
-        : Self.View,
+      chooser(null).View,
     );
-  };
 
   /**
    * A descriptor for a more complex POJO.
@@ -3457,7 +3439,6 @@ declare function sequenceViewFixLen<T, V>(
 type index$q_ClassConstructor<T> = ClassConstructor<T>;
 type index$q_Codec<T> = Codec<T>;
 type index$q_CodecRecord<T> = CodecRecord<T>;
-type index$q_CodecWithView<T, V> = CodecWithView<T, V>;
 declare const index$q_DEFAULT_START_LENGTH: typeof DEFAULT_START_LENGTH;
 type index$q_Decode<T> = Decode<T>;
 type index$q_Decoder = Decoder;
@@ -3498,7 +3479,7 @@ declare const index$q_tryAsExactBytes: typeof tryAsExactBytes;
 declare const index$q_validateLength: typeof validateLength;
 declare namespace index$q {
   export { index$q_DEFAULT_START_LENGTH as DEFAULT_START_LENGTH, index$q_Decoder as Decoder, index$q_Descriptor as Descriptor, index$q_Encoder as Encoder, index$q_MASKS as MASKS, index$q_MAX_LENGTH as MAX_LENGTH, index$q_ObjectView as ObjectView, index$q_SequenceView as SequenceView, index$q_TYPICAL_DICTIONARY_LENGTH as TYPICAL_DICTIONARY_LENGTH, index$q_TYPICAL_SEQUENCE_LENGTH as TYPICAL_SEQUENCE_LENGTH, index$q_ViewField as ViewField, index$q_addSizeHints as addSizeHints, codec$1 as codec, index$q_decodeVariableLengthExtraBytes as decodeVariableLengthExtraBytes, index$q_exactHint as exactHint, index$q_forEachDescriptor as forEachDescriptor, index$q_hasUniqueView as hasUniqueView, index$q_objectView as objectView, index$q_readonlyArray as readonlyArray, index$q_sequenceViewFixLen as sequenceViewFixLen, index$q_sequenceViewVarLen as sequenceViewVarLen, index$q_tryAsExactBytes as tryAsExactBytes, index$q_validateLength as validateLength };
-  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_CodecWithView as CodecWithView, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
+  export type { index$q_ClassConstructor as ClassConstructor, index$q_Codec as Codec, index$q_CodecRecord as CodecRecord, index$q_Decode as Decode, index$q_DescribedBy as DescribedBy, index$q_DescriptorRecord as DescriptorRecord, index$q_Encode as Encode, index$q_LengthRange as LengthRange, index$q_OptionalRecord as OptionalRecord, Options$1 as Options, index$q_PropertyKeys as PropertyKeys, index$q_SimpleDescriptorRecord as SimpleDescriptorRecord, index$q_SizeHint as SizeHint, index$q_ViewOf as ViewOf };
 }
 
 /**
@@ -6936,17 +6917,6 @@ declare function emptyBlock(slot: TimeSlot = 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.
- */
-declare function reencodeAsView<T, V>(codec: Descriptor<T, V>, object: T, chainSpec?: ChainSpec): V {
-  const encoded = Encoder.encodeObject(codec, object, chainSpec);
-  return Decoder.decodeObject(codec.View, encoded, chainSpec);
-}
-
 type index$l_Block = Block;
 declare const index$l_Block: typeof Block;
 type index$l_BlockView = BlockView;
@@ -6996,7 +6966,6 @@ declare const index$l_guarantees: typeof guarantees;
 declare const index$l_headerViewWithHashCodec: typeof headerViewWithHashCodec;
 declare const index$l_legacyDescriptor: typeof legacyDescriptor;
 declare const index$l_preimage: typeof preimage;
-declare const index$l_reencodeAsView: typeof reencodeAsView;
 declare const index$l_refineContext: typeof refineContext;
 declare const index$l_tickets: typeof tickets;
 declare const index$l_tryAsCoreIndex: typeof tryAsCoreIndex;
@@ -7013,7 +6982,7 @@ declare const index$l_workPackage: typeof workPackage;
 declare const index$l_workReport: typeof workReport;
 declare const index$l_workResult: typeof workResult;
 declare namespace index$l {
-  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_reencodeAsView as reencodeAsView, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
+  export { index$l_Block as Block, index$l_EpochMarker as EpochMarker, index$l_Extrinsic as Extrinsic, index$l_Header as Header, index$l_HeaderViewWithHash as HeaderViewWithHash, index$l_MAX_NUMBER_OF_SEGMENTS as MAX_NUMBER_OF_SEGMENTS, index$l_TicketsMarker as TicketsMarker, index$l_ValidatorKeys as ValidatorKeys, index$l_W_E as W_E, index$l_W_S as W_S, index$l_assurances as assurances, index$l_codecPerEpochBlock as codecPerEpochBlock, index$l_codecPerValidator as codecPerValidator, codec as codecUtils, index$l_disputes as disputes, index$l_emptyBlock as emptyBlock, index$l_encodeUnsealedHeader as encodeUnsealedHeader, index$l_guarantees as guarantees, index$l_headerViewWithHashCodec as headerViewWithHashCodec, index$l_legacyDescriptor as legacyDescriptor, index$l_preimage as preimage, index$l_refineContext as refineContext, index$l_tickets as tickets, index$l_tryAsCoreIndex as tryAsCoreIndex, index$l_tryAsEpoch as tryAsEpoch, index$l_tryAsPerEpochBlock as tryAsPerEpochBlock, index$l_tryAsPerValidator as tryAsPerValidator, index$l_tryAsSegmentIndex as tryAsSegmentIndex, index$l_tryAsServiceGas as tryAsServiceGas, index$l_tryAsServiceId as tryAsServiceId, index$l_tryAsTimeSlot as tryAsTimeSlot, index$l_tryAsValidatorIndex as tryAsValidatorIndex, index$l_workItem as workItem, index$l_workPackage as workPackage, index$l_workReport as workReport, index$l_workResult as workResult };
   export type { index$l_BlockView as BlockView, index$l_CodeHash as CodeHash, index$l_CoreIndex as CoreIndex, index$l_EntropyHash as EntropyHash, index$l_Epoch as Epoch, index$l_EpochMarkerView as EpochMarkerView, index$l_ExtrinsicHash as ExtrinsicHash, index$l_ExtrinsicView as ExtrinsicView, index$l_HeaderHash as HeaderHash, index$l_HeaderView as HeaderView, index$l_PerEpochBlock as PerEpochBlock, index$l_PerValidator as PerValidator, index$l_SEGMENT_BYTES as SEGMENT_BYTES, index$l_Segment as Segment, index$l_SegmentIndex as SegmentIndex, index$l_ServiceGas as ServiceGas, index$l_ServiceId as ServiceId, index$l_StateRootHash as StateRootHash, index$l_TicketsMarkerView as TicketsMarkerView, index$l_TimeSlot as TimeSlot, index$l_ValidatorIndex as ValidatorIndex, index$l_WorkReportHash as WorkReportHash };
 }
 
@@ -9152,77 +9121,6 @@ declare function accumulationOutputComparator(a: AccumulationOutput, b: Accumula
   return Ordering.Equal;
 }
 
-/**
- * `J`: The maximum sum of dependency items in a work-report.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
- */
-declare const MAX_REPORT_DEPENDENCIES = 8;
-type MAX_REPORT_DEPENDENCIES = typeof MAX_REPORT_DEPENDENCIES;
-
-/**
- * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
- */
-declare class NotYetAccumulatedReport extends WithDebug {
-  static Codec = codec.Class(NotYetAccumulatedReport, {
-    report: WorkReport.Codec,
-    dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(), {
-      typicalLength: MAX_REPORT_DEPENDENCIES / 2,
-      maxLength: MAX_REPORT_DEPENDENCIES,
-      minLength: 0,
-    }),
-  });
-
-  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
-    return new NotYetAccumulatedReport(report, dependencies);
-  }
-
-  private constructor(
-    /**
-     * Each of these were made available at most one epoch ago
-     * but have or had unfulfilled dependencies.
-     */
-    readonly report: WorkReport,
-    /**
-     * Alongside the work-report itself, we retain its un-accumulated
-     * dependencies, a set of work-package hashes.
-     *
-     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
-     */
-    readonly dependencies: KnownSizeArray<WorkPackageHash, `[0..${MAX_REPORT_DEPENDENCIES})`>,
-  ) {
-    super();
-  }
-}
-
-/**
- * Accumulation queue state entry.
- */
-type AccumulationQueue = PerEpochBlock<readonly NotYetAccumulatedReport[]>;
-
-declare const accumulationQueueCodec = codecPerEpochBlock(
-  readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec)),
-);
-
-type AccumulationQueueView = DescribedBy<typeof accumulationQueueCodec.View>;
-
-/** One entry of kind `T` for each core. */
-type PerCore<T> = KnownSizeArray<T, "number of cores">;
-/** Check if given array has correct length before casting to the opaque type. */
-declare function tryAsPerCore<T>(array: T[], spec: ChainSpec): PerCore<T> {
-  check`
-    ${array.length === spec.coresCount}
-    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
-  `;
-  return asOpaqueType(array);
-}
-declare const codecPerCore = <T, V>(val: Descriptor<T, V>): Descriptor<PerCore<T>, SequenceView<T, V>> =>
-  codecWithContext((context) => {
-    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
-  });
-
 /**
  * Assignment of particular work report to a core.
  *
@@ -9251,39 +9149,20 @@ declare class AvailabilityAssignment extends WithDebug {
   }
 }
 
-declare const availabilityAssignmentsCodec = codecPerCore(codec.optional(AvailabilityAssignment.Codec));
-
-type AvailabilityAssignmentsView = DescribedBy<typeof availabilityAssignmentsCodec.View>;
-
-/** `O`: Maximal authorization pool size. */
-declare const MAX_AUTH_POOL_SIZE = O;
-type MAX_AUTH_POOL_SIZE = typeof MAX_AUTH_POOL_SIZE;
-
-/** `Q`: Size of the authorization queue. */
-declare const AUTHORIZATION_QUEUE_SIZE = Q;
-type AUTHORIZATION_QUEUE_SIZE = typeof AUTHORIZATION_QUEUE_SIZE;
-
-/** A pool of authorization hashes that is filled from the queue. */
-type AuthorizationPool = KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>;
-
-/**
- * A fixed-size queue of authorization hashes used to fill up the pool.
- *
- * Can be set using `ASSIGN` host call in batches of `AUTHORIZATION_QUEUE_SIZE`.
- */
-type AuthorizationQueue = FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>;
-
-declare const authPoolsCodec = codecPerCore<AuthorizationPool, SequenceView<AuthorizerHash>>(
-  codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), {
-    minLength: 0,
-    maxLength: MAX_AUTH_POOL_SIZE,
-    typicalLength: MAX_AUTH_POOL_SIZE,
-  }),
-);
-
-declare const authQueuesCodec = codecPerCore<AuthorizationQueue, SequenceView<AuthorizerHash>>(
-  codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), AUTHORIZATION_QUEUE_SIZE),
-);
+/** One entry of kind `T` for each core. */
+type PerCore<T> = KnownSizeArray<T, "number of cores">;
+/** Check if given array has correct length before casting to the opaque type. */
+declare function tryAsPerCore<T>(array: T[], spec: ChainSpec): PerCore<T> {
+  check`
+    ${array.length === spec.coresCount}
+    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
+  `;
+  return asOpaqueType(array);
+}
+declare const codecPerCore = <T, V>(val: Descriptor<T, V>): Descriptor<PerCore<T>, SequenceView<T, V>> =>
+  codecWithContext((context) => {
+    return codecKnownSizeArray(val, { fixedLength: context.coresCount });
+  });
 
 declare const sortedSetCodec = <T extends OpaqueHash>() =>
   readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert<ImmutableSortedSet<T>>(
@@ -9366,93 +9245,415 @@ declare function hashComparator<V extends OpaqueHash>(a: V, b: V) {
   return a.compare(b);
 }
 
-declare const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
+/**
+ * `J`: The maximum sum of dependency items in a work-report.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/416a00416a00?v=0.6.2
+ */
+declare const MAX_REPORT_DEPENDENCIES = 8;
+type MAX_REPORT_DEPENDENCIES = typeof MAX_REPORT_DEPENDENCIES;
 
-/** Merkle Mountain Range peaks. */
-interface MmrPeaks<H extends OpaqueHash> {
-  /**
-   * Peaks at particular positions.
-   *
-   * In case there is no merkle trie at given index, `null` is placed.
-   */
-  peaks: readonly (H | null)[];
-}
+/** `Q`: Size of the authorization queue. */
+declare const AUTHORIZATION_QUEUE_SIZE = Q;
+type AUTHORIZATION_QUEUE_SIZE = typeof AUTHORIZATION_QUEUE_SIZE;
 
-/** Hasher interface for MMR. */
-interface MmrHasher<H extends OpaqueHash> {
-  /** Hash two items together. */
-  hashConcat(a: H, b: H): H;
-  /** Hash two items together with extra bytes blob prepended. */
-  hashConcatPrepend(id: BytesBlob, a: H, b: H): H;
-}
+/** `O`: Maximal authorization pool size. */
+declare const MAX_AUTH_POOL_SIZE = O;
+type MAX_AUTH_POOL_SIZE = typeof MAX_AUTH_POOL_SIZE;
 
 /**
- * Merkle Mountain Range.
+ * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/3aa0023aa002?v=0.6.2
+ * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
  */
-declare class MerkleMountainRange<H extends OpaqueHash> {
-  /** Construct an empty MMR. */
-  static empty<H extends OpaqueHash>(hasher: MmrHasher<H>) {
-    return new MerkleMountainRange(hasher);
-  }
+declare class NotYetAccumulatedReport extends WithDebug {
+  static Codec = codec.Class(NotYetAccumulatedReport, {
+    report: WorkReport.Codec,
+    dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>(), {
+      typicalLength: MAX_REPORT_DEPENDENCIES / 2,
+      maxLength: MAX_REPORT_DEPENDENCIES,
+      minLength: 0,
+    }),
+  });
 
-  /** Construct a new MMR from existing peaks. */
-  static fromPeaks<H extends OpaqueHash>(hasher: MmrHasher<H>, mmr: MmrPeaks<H>) {
-    return new MerkleMountainRange(
-      hasher,
-      mmr.peaks
-        .reduce((acc: Mountain<H>[], peak, index) => {
-          if (peak !== null) {
-            acc.push(Mountain.fromPeak(peak, 2 ** index));
-          }
-          return acc;
-        }, [])
-        .reverse(),
-    );
+  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
+    return new NotYetAccumulatedReport(report, dependencies);
   }
 
   private constructor(
-    private readonly hasher: MmrHasher<H>,
-    /** Store non-empty merkle tries (mountains) ordered by descending size. */
-    private readonly mountains: Mountain<H>[] = [],
-  ) {}
-
-  /**
-   * Append a new hash to the MMR structure.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/3b11003b1100?v=0.6.2
-   */
-  append(hash: H) {
-    let newMountain = Mountain.fromPeak(hash, 1);
+    /**
+     * Each of these were made available at most one epoch ago
+     * but have or had unfulfilled dependencies.
+     */
+    readonly report: WorkReport,
+    /**
+     * Alongside the work-report itself, we retain its un-accumulated
+     * dependencies, a set of work-package hashes.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/165800165800
+     */
+    readonly dependencies: KnownSizeArray<WorkPackageHash, `[0..${MAX_REPORT_DEPENDENCIES})`>,
+  ) {
+    super();
+  }
+}
 
-    for (;;) {
-      const last = this.mountains.pop();
-      if (last === undefined) {
-        this.mountains.push(newMountain);
-        return;
-      }
+/**
+ * `B_S`: The basic minimum balance which all services require.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
+ */
+declare 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
+ */
+declare 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
+ */
+declare const ELECTIVE_BYTE_BALANCE = 1n;
 
-      if (last.size !== newMountain.size) {
-        this.mountains.push(last);
-        this.mountains.push(newMountain);
-        return;
-      }
+declare const zeroSizeHint: SizeHint = {
+  bytes: 0,
+  isExact: true,
+};
 
-      newMountain = last.mergeWith(this.hasher, newMountain);
-    }
-  }
+/** 0-byte read, return given default value */
+declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
+  Descriptor.new<T>(
+    "ignoreValue",
+    zeroSizeHint,
+    (_e, _v) => {},
+    (_d) => defaultValue,
+    (_s) => {},
+  );
 
-  /**
-   * Root of the entire structure.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/3b20013b2001?v=0.6.2
-   */
-  getSuperPeakHash(): H {
-    if (this.mountains.length === 0) {
-      return Bytes.zero(HASH_SIZE).asOpaque();
-    }
-    const revMountains = this.mountains.slice().reverse();
+/** Encode and decode object with leading version number. */
+declare const codecWithVersion = <T>(val: Descriptor<T>): Descriptor<T> =>
+  Descriptor.new<T>(
+    "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
+ */
+declare class ServiceAccountInfo extends WithDebug {
+  static Codec = codec.Class(ServiceAccountInfo, {
+    codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
+    balance: codec.u64,
+    accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    gratisStorage: codec.u64,
+    storageUtilisationCount: codec.u32,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+  });
+
+  static create(a: CodecRecord<ServiceAccountInfo>) {
+    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)`
+   * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
+   */
+  static calculateThresholdBalance(items: U32, bytes: U64, gratisStorage: U64): U64 {
+    const storageCost =
+      BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
+
+    if (storageCost < 0n) {
+      return tryAsU64(0);
+    }
+
+    if (storageCost >= 2n ** 64n) {
+      return tryAsU64(2n ** 64n - 1n);
+    }
+
+    return tryAsU64(storageCost);
+  }
+
+  private constructor(
+    /** `a_c`: Hash of the service code. */
+    public readonly codeHash: CodeHash,
+    /** `a_b`: Current account balance. */
+    public readonly balance: U64,
+    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
+    public readonly accumulateMinGas: ServiceGas,
+    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
+    public readonly onTransferMinGas: ServiceGas,
+    /** `a_o`: Total number of octets in storage. */
+    public readonly storageUtilisationBytes: U64,
+    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
+    public readonly gratisStorage: U64,
+    /** `a_i`: Number of items in storage. */
+    public readonly storageUtilisationCount: U32,
+    /** `a_r`: Creation account time slot. */
+    public readonly created: TimeSlot,
+    /** `a_a`: Most recent accumulation time slot. */
+    public readonly lastAccumulation: TimeSlot,
+    /** `a_p`: Parent service ID. */
+    public readonly parentService: ServiceId,
+  ) {
+    super();
+  }
+}
+
+declare class PreimageItem extends WithDebug {
+  static Codec = codec.Class(PreimageItem, {
+    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
+    blob: codec.blob,
+  });
+
+  static create({ hash, blob }: CodecRecord<PreimageItem>) {
+    return new PreimageItem(hash, blob);
+  }
+
+  private constructor(
+    readonly hash: PreimageHash,
+    readonly blob: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+type StorageKey = Opaque<BytesBlob, "storage key">;
+
+declare class StorageItem extends WithDebug {
+  static Codec = codec.Class(StorageItem, {
+    key: codec.blob.convert(
+      (i) => i,
+      (o) => asOpaqueType(o),
+    ),
+    value: codec.blob,
+  });
+
+  static create({ key, value }: CodecRecord<StorageItem>) {
+    return new StorageItem(key, value);
+  }
+
+  private constructor(
+    readonly key: StorageKey,
+    readonly value: BytesBlob,
+  ) {
+    super();
+  }
+}
+
+declare const MAX_LOOKUP_HISTORY_SLOTS = 3;
+type LookupHistorySlots = KnownSizeArray<TimeSlot, `0-${typeof MAX_LOOKUP_HISTORY_SLOTS} timeslots`>;
+declare function tryAsLookupHistorySlots(items: readonly TimeSlot[]): LookupHistorySlots {
+  const knownSize = asKnownSize(items) as LookupHistorySlots;
+  if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
+    throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
+  }
+  return knownSize;
+}
+
+/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
+declare class LookupHistoryItem {
+  constructor(
+    public readonly hash: PreimageHash,
+    public readonly length: U32,
+    /**
+     * Preimage availability history as a sequence of time slots.
+     * See PreimageStatus and the following GP fragment for more details.
+     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
+    public readonly slots: LookupHistorySlots,
+  ) {}
+
+  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
+    if ("slots" in item) {
+      return item.slots.length === 0;
+    }
+    return item.length === 0;
+  }
+}
+
+/** Dictionary entry of services that auto-accumulate every block. */
+declare class AutoAccumulate {
+  static Codec = codec.Class(AutoAccumulate, {
+    service: codec.u32.asOpaque<ServiceId>(),
+    gasLimit: codec.u64.asOpaque<ServiceGas>(),
+  });
+
+  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
+    return new AutoAccumulate(service, gasLimit);
+  }
+
+  private constructor(
+    /** Service id that auto-accumulates. */
+    readonly service: ServiceId,
+    /** Gas limit for auto-accumulation. */
+    readonly gasLimit: ServiceGas,
+  ) {}
+}
+
+/**
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
+ */
+declare class PrivilegedServices {
+  /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
+  static Codec = codec.Class(PrivilegedServices, {
+    manager: codec.u32.asOpaque<ServiceId>(),
+    assigners: codecPerCore(codec.u32.asOpaque<ServiceId>()),
+    delegator: codec.u32.asOpaque<ServiceId>(),
+    registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
+      ? codec.u32.asOpaque<ServiceId>()
+      : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
+    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
+  });
+
+  static create(a: CodecRecord<PrivilegedServices>) {
+    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+  }
+
+  private 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
+     */
+    readonly manager: ServiceId,
+    /** `χ_V`: Managers validator keys. */
+    readonly delegator: ServiceId,
+    /**
+     * `χ_R`: Manages the creation of services in protected range.
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
+     */
+    readonly registrar: ServiceId,
+    /** `χ_A`: Manages authorization queue one for each core. */
+    readonly assigners: PerCore<ServiceId>,
+    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
+    readonly autoAccumulateServices: readonly AutoAccumulate[],
+  ) {}
+}
+
+declare const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
+
+/** Merkle Mountain Range peaks. */
+interface MmrPeaks<H extends OpaqueHash> {
+  /**
+   * Peaks at particular positions.
+   *
+   * In case there is no merkle trie at given index, `null` is placed.
+   */
+  peaks: readonly (H | null)[];
+}
+
+/** Hasher interface for MMR. */
+interface MmrHasher<H extends OpaqueHash> {
+  /** Hash two items together. */
+  hashConcat(a: H, b: H): H;
+  /** Hash two items together with extra bytes blob prepended. */
+  hashConcatPrepend(id: BytesBlob, a: H, b: H): H;
+}
+
+/**
+ * Merkle Mountain Range.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/3aa0023aa002?v=0.6.2
+ */
+declare class MerkleMountainRange<H extends OpaqueHash> {
+  /** Construct an empty MMR. */
+  static empty<H extends OpaqueHash>(hasher: MmrHasher<H>) {
+    return new MerkleMountainRange(hasher);
+  }
+
+  /** Construct a new MMR from existing peaks. */
+  static fromPeaks<H extends OpaqueHash>(hasher: MmrHasher<H>, mmr: MmrPeaks<H>) {
+    return new MerkleMountainRange(
+      hasher,
+      mmr.peaks
+        .reduce((acc: Mountain<H>[], peak, index) => {
+          if (peak !== null) {
+            acc.push(Mountain.fromPeak(peak, 2 ** index));
+          }
+          return acc;
+        }, [])
+        .reverse(),
+    );
+  }
+
+  private constructor(
+    private readonly hasher: MmrHasher<H>,
+    /** Store non-empty merkle tries (mountains) ordered by descending size. */
+    private readonly mountains: Mountain<H>[] = [],
+  ) {}
+
+  /**
+   * Append a new hash to the MMR structure.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/3b11003b1100?v=0.6.2
+   */
+  append(hash: H) {
+    let newMountain = Mountain.fromPeak(hash, 1);
+
+    for (;;) {
+      const last = this.mountains.pop();
+      if (last === undefined) {
+        this.mountains.push(newMountain);
+        return;
+      }
+
+      if (last.size !== newMountain.size) {
+        this.mountains.push(last);
+        this.mountains.push(newMountain);
+        return;
+      }
+
+      newMountain = last.mergeWith(this.hasher, newMountain);
+    }
+  }
+
+  /**
+   * Root of the entire structure.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/3b20013b2001?v=0.6.2
+   */
+  getSuperPeakHash(): H {
+    if (this.mountains.length === 0) {
+      return Bytes.zero(HASH_SIZE).asOpaque();
+    }
+    const revMountains = this.mountains.slice().reverse();
     const length = revMountains.length;
     let lastHash = revMountains[0].peak;
     for (let i = 1; i < length; i++) {
@@ -9562,11 +9763,6 @@ declare class BlockState extends WithDebug {
   }
 }
 
-/**
- * Recent history of blocks.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
- */
 declare class RecentBlocks extends WithDebug {
   static Codec = codec.Class(RecentBlocks, {
     blocks: codecKnownSizeArray(BlockState.Codec, {
@@ -9579,12 +9775,6 @@ declare class RecentBlocks extends WithDebug {
     }),
   });
 
-  static empty() {
-    return new RecentBlocks(asKnownSize([]), {
-      peaks: [],
-    });
-  }
-
   static create(a: CodecRecord<RecentBlocks>) {
     return new RecentBlocks(a.blocks, a.accumulationLog);
   }
@@ -9595,449 +9785,229 @@ declare class RecentBlocks extends WithDebug {
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fea010fea01?v=0.6.7
      */
     public readonly blocks: BlocksState,
-    /**
-     * Accumulation output log.
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0f02020f0202?v=0.6.7
-     */
-    public readonly accumulationLog: MmrPeaks<KeccakHash>,
-  ) {
-    super();
-  }
-}
-
-type RecentBlocksView = DescribedBy<typeof RecentBlocks.Codec.View>;
-
-type RecentlyAccumulated = PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
-
-declare const recentlyAccumulatedCodec = codecPerEpochBlock<
-  ImmutableHashSet<WorkPackageHash>,
-  SequenceView<WorkPackageHash>
->(
-  codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>()).convert(
-    (x) => Array.from(x),
-    (x) => HashSet.from(x),
-  ),
-);
-
-type RecentlyAccumulatedView = DescribedBy<typeof recentlyAccumulatedCodec.View>;
-
-/**
- * Fixed size of validator metadata.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
- */
-declare const VALIDATOR_META_BYTES = 128;
-type VALIDATOR_META_BYTES = typeof VALIDATOR_META_BYTES;
-
-/**
- * Details about validators' identity.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
- */
-declare class ValidatorData extends WithDebug {
-  static Codec = codec.Class(ValidatorData, {
-    bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>(),
-    ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque<Ed25519Key>(),
-    bls: codec.bytes(BLS_KEY_BYTES).asOpaque<BlsKey>(),
-    metadata: codec.bytes(VALIDATOR_META_BYTES),
-  });
-
-  static create({ ed25519, bandersnatch, bls, metadata }: CodecRecord<ValidatorData>) {
-    return new ValidatorData(bandersnatch, ed25519, bls, metadata);
-  }
-
-  private constructor(
-    /** Bandersnatch public key. */
-    public readonly bandersnatch: BandersnatchKey,
-    /** ED25519 key data. */
-    public readonly ed25519: Ed25519Key,
-    /** BLS public key. */
-    public readonly bls: BlsKey,
-    /** Validator-defined additional metdata. */
-    public readonly metadata: Bytes<VALIDATOR_META_BYTES>,
-  ) {
-    super();
-  }
-}
-
-type ValidatorDataView = DescribedBy<typeof ValidatorData.Codec.View>;
-
-declare const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
-
-declare enum SafroleSealingKeysKind {
-  Tickets = 0,
-  Keys = 1,
-}
-
-type SafroleSealingKeys =
-  | {
-      kind: SafroleSealingKeysKind.Keys;
-      keys: PerEpochBlock<BandersnatchKey>;
-    }
-  | {
-      kind: SafroleSealingKeysKind.Tickets;
-      tickets: PerEpochBlock<Ticket>;
-    };
-
-declare const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>();
-
-declare class SafroleSealingKeysData extends WithDebug {
-  static Codec = codecWithContext((context) => {
-    return codec.custom<SafroleSealingKeys>(
-      {
-        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<BandersnatchKey>(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: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
-  }
-
-  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
-  }
-
-  private constructor(
-    readonly kind: SafroleSealingKeysKind,
-    readonly keys?: PerEpochBlock<BandersnatchKey>,
-    readonly tickets?: PerEpochBlock<Ticket>,
-  ) {
-    super();
-  }
-}
-
-declare class SafroleData {
-  static Codec = codec.Class(SafroleData, {
-    nextValidatorData: codecPerValidator(ValidatorData.Codec),
-    epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque<BandersnatchRingRoot>(),
-    sealingKeySeries: SafroleSealingKeysData.Codec,
-    ticketsAccumulator: readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
-  });
-
-  static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
-    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
-  }
-
-  private constructor(
-    /** gamma_k */
-    public readonly nextValidatorData: PerValidator<ValidatorData>,
-    /** gamma_z */
-    public readonly epochRoot: BandersnatchRingRoot,
-    /** gamma_s */
-    public readonly sealingKeySeries: SafroleSealingKeys,
-    /** gamma_a */
-    public readonly ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">,
-  ) {}
-}
-
-type SafroleDataView = DescribedBy<typeof SafroleData.Codec.View>;
-
-/**
- * `B_S`: The basic minimum balance which all services require.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
- */
-declare 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
- */
-declare const ELECTIVE_ITEM_BALANCE = 10n;
+    /**
+     * Accumulation output log.
+     * https://graypaper.fluffylabs.dev/#/7e6ff6a/0f02020f0202?v=0.6.7
+     */
+    public readonly accumulationLog: MmrPeaks<KeccakHash>,
+  ) {
+    super();
+  }
+}
+
 /**
- * `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
  */
-declare const ELECTIVE_BYTE_BALANCE = 1n;
-
-declare const zeroSizeHint: SizeHint = {
-  bytes: 0,
-  isExact: true,
-};
-
-/** 0-byte read, return given default value */
-declare const ignoreValueWithDefault = <T>(defaultValue: T) =>
-  Descriptor.new<T>(
-    "ignoreValue",
-    zeroSizeHint,
-    (_e, _v) => {},
-    (_d) => defaultValue,
-    (_s) => {},
-  );
-
-/** Encode and decode object with leading version number. */
-declare const codecWithVersion = <T>(val: Descriptor<T>): Descriptor<T> =>
-  Descriptor.new<T>(
-    "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);
+declare class RecentBlocksHistory extends WithDebug {
+  static Codec = Descriptor.new<RecentBlocksHistory>(
+    "RecentBlocksHistory",
+    RecentBlocks.Codec.sizeHint,
+    (encoder, value) => RecentBlocks.Codec.encode(encoder, value.asCurrent()),
+    (decoder) => {
+      const recentBlocks = RecentBlocks.Codec.decode(decoder);
+      return RecentBlocksHistory.create(recentBlocks);
     },
-    (s) => {
-      s.varU64();
-      val.skip(s);
+    (skip) => {
+      return RecentBlocks.Codec.skip(skip);
     },
   );
 
-/**
- * Service account details.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/108301108301?v=0.6.7
- */
-declare class ServiceAccountInfo extends WithDebug {
-  static Codec = codec.Class(ServiceAccountInfo, {
-    codeHash: codec.bytes(HASH_SIZE).asOpaque<CodeHash>(),
-    balance: codec.u64,
-    accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-    onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-    storageUtilisationBytes: codec.u64,
-    gratisStorage: codec.u64,
-    storageUtilisationCount: codec.u32,
-    created: codec.u32.convert((x) => x, tryAsTimeSlot),
-    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
-    parentService: codec.u32.convert((x) => x, tryAsServiceId),
-  });
+  static create(recentBlocks: RecentBlocks) {
+    return new RecentBlocksHistory(recentBlocks);
+  }
 
-  static create(a: CodecRecord<ServiceAccountInfo>) {
-    return new ServiceAccountInfo(
-      a.codeHash,
-      a.balance,
-      a.accumulateMinGas,
-      a.onTransferMinGas,
-      a.storageUtilisationBytes,
-      a.gratisStorage,
-      a.storageUtilisationCount,
-      a.created,
-      a.lastAccumulation,
-      a.parentService,
+  static empty() {
+    return RecentBlocksHistory.create(
+      RecentBlocks.create({
+        blocks: asKnownSize([]),
+        accumulationLog: { peaks: [] },
+      }),
     );
   }
 
   /**
-   * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
+   * Returns the block's BEEFY super peak.
    */
-  static calculateThresholdBalance(items: U32, bytes: U64, gratisStorage: U64): U64 {
-    const storageCost =
-      BASE_SERVICE_BALANCE + ELECTIVE_ITEM_BALANCE * BigInt(items) + ELECTIVE_BYTE_BALANCE * bytes - gratisStorage;
-
-    if (storageCost < 0n) {
-      return tryAsU64(0);
-    }
-
-    if (storageCost >= 2n ** 64n) {
-      return tryAsU64(2n ** 64n - 1n);
-    }
-
-    return tryAsU64(storageCost);
+  static accumulationResult(block: BlockState): KeccakHash {
+    return (block as BlockState).accumulationResult;
   }
 
-  private constructor(
-    /** `a_c`: Hash of the service code. */
-    public readonly codeHash: CodeHash,
-    /** `a_b`: Current account balance. */
-    public readonly balance: U64,
-    /** `a_g`: Minimal gas required to execute Accumulate entrypoint. */
-    public readonly accumulateMinGas: ServiceGas,
-    /** `a_m`: Minimal gas required to execute On Transfer entrypoint. */
-    public readonly onTransferMinGas: ServiceGas,
-    /** `a_o`: Total number of octets in storage. */
-    public readonly storageUtilisationBytes: U64,
-    /** `a_f`: Cost-free storage. Decreases both storage item count and total byte size. */
-    public readonly gratisStorage: U64,
-    /** `a_i`: Number of items in storage. */
-    public readonly storageUtilisationCount: U32,
-    /** `a_r`: Creation account time slot. */
-    public readonly created: TimeSlot,
-    /** `a_a`: Most recent accumulation time slot. */
-    public readonly lastAccumulation: TimeSlot,
-    /** `a_p`: Parent service ID. */
-    public readonly parentService: ServiceId,
-  ) {
+  private constructor(private readonly current: RecentBlocks | null) {
     super();
   }
-}
 
-type ServiceAccountInfoView = DescribedBy<typeof ServiceAccountInfo.Codec.View>;
+  /** History of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
+  get blocks(): readonly BlockState[] {
+    if (this.current !== null) {
+      return this.current.blocks;
+    }
 
-declare class PreimageItem extends WithDebug {
-  static Codec = codec.Class(PreimageItem, {
-    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
-    blob: codec.blob,
-  });
+    throw new Error("RecentBlocksHistory is in invalid state");
+  }
 
-  static create({ hash, blob }: CodecRecord<PreimageItem>) {
-    return new PreimageItem(hash, blob);
+  asCurrent() {
+    if (this.current === null) {
+      throw new Error("Cannot access current RecentBlocks format");
+    }
+    return this.current;
   }
 
-  private constructor(
-    readonly hash: PreimageHash,
-    readonly blob: BytesBlob,
-  ) {
-    super();
+  updateBlocks(blocks: BlockState[]): RecentBlocksHistory {
+    if (this.current !== null) {
+      return RecentBlocksHistory.create(
+        RecentBlocks.create({
+          ...this.current,
+          blocks: asOpaqueType(blocks as BlockState[]),
+        }),
+      );
+    }
+
+    throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
   }
 }
 
-type StorageKey = Opaque<BytesBlob, "storage key">;
+/**
+ * Fixed size of validator metadata.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d55010d5501
+ */
+declare const VALIDATOR_META_BYTES = 128;
+type VALIDATOR_META_BYTES = typeof VALIDATOR_META_BYTES;
 
-declare class StorageItem extends WithDebug {
-  static Codec = codec.Class(StorageItem, {
-    key: codec.blob.convert(
-      (i) => i,
-      (o) => asOpaqueType(o),
-    ),
-    value: codec.blob,
+/**
+ * Details about validators' identity.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
+ */
+declare class ValidatorData extends WithDebug {
+  static Codec = codec.Class(ValidatorData, {
+    bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>(),
+    ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque<Ed25519Key>(),
+    bls: codec.bytes(BLS_KEY_BYTES).asOpaque<BlsKey>(),
+    metadata: codec.bytes(VALIDATOR_META_BYTES),
   });
 
-  static create({ key, value }: CodecRecord<StorageItem>) {
-    return new StorageItem(key, value);
+  static create({ ed25519, bandersnatch, bls, metadata }: CodecRecord<ValidatorData>) {
+    return new ValidatorData(bandersnatch, ed25519, bls, metadata);
   }
 
   private constructor(
-    readonly key: StorageKey,
-    readonly value: BytesBlob,
+    /** Bandersnatch public key. */
+    public readonly bandersnatch: BandersnatchKey,
+    /** ED25519 key data. */
+    public readonly ed25519: Ed25519Key,
+    /** BLS public key. */
+    public readonly bls: BlsKey,
+    /** Validator-defined additional metdata. */
+    public readonly metadata: Bytes<VALIDATOR_META_BYTES>,
   ) {
     super();
   }
 }
 
-declare const MAX_LOOKUP_HISTORY_SLOTS = 3;
-type LookupHistorySlots = KnownSizeArray<TimeSlot, `0-${typeof MAX_LOOKUP_HISTORY_SLOTS} timeslots`>;
-declare function tryAsLookupHistorySlots(items: readonly TimeSlot[]): LookupHistorySlots {
-  const knownSize = asKnownSize(items) as LookupHistorySlots;
-  if (knownSize.length > MAX_LOOKUP_HISTORY_SLOTS) {
-    throw new Error(`Lookup history items must contain 0-${MAX_LOOKUP_HISTORY_SLOTS} timeslots.`);
-  }
-  return knownSize;
+declare enum SafroleSealingKeysKind {
+  Tickets = 0,
+  Keys = 1,
 }
 
-/** https://graypaper.fluffylabs.dev/#/5f542d7/115400115800 */
-declare class LookupHistoryItem {
-  constructor(
-    public readonly hash: PreimageHash,
-    public readonly length: U32,
-    /**
-     * Preimage availability history as a sequence of time slots.
-     * See PreimageStatus and the following GP fragment for more details.
-     * https://graypaper.fluffylabs.dev/#/5f542d7/11780011a500 */
-    public readonly slots: LookupHistorySlots,
-  ) {}
-
-  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
-    if ("slots" in item) {
-      return item.slots.length === 0;
+type SafroleSealingKeys =
+  | {
+      kind: SafroleSealingKeysKind.Keys;
+      keys: PerEpochBlock<BandersnatchKey>;
     }
-    return item.length === 0;
-  }
-}
+  | {
+      kind: SafroleSealingKeysKind.Tickets;
+      tickets: PerEpochBlock<Ticket>;
+    };
+
+declare const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>();
+
+declare class SafroleSealingKeysData extends WithDebug {
+  static Codec = codecWithContext((context) => {
+    return codec.custom<SafroleSealingKeys>(
+      {
+        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<BandersnatchKey>(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;
+        }
 
-/** Dictionary entry of services that auto-accumulate every block. */
-declare class AutoAccumulate {
-  static Codec = codec.Class(AutoAccumulate, {
-    service: codec.u32.asOpaque<ServiceId>(),
-    gasLimit: codec.u64.asOpaque<ServiceGas>(),
+        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+      },
+    );
   });
 
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
+  static keys(keys: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
+  }
+
+  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
   }
 
   private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
+    readonly kind: SafroleSealingKeysKind,
+    readonly keys?: PerEpochBlock<BandersnatchKey>,
+    readonly tickets?: PerEpochBlock<Ticket>,
+  ) {
+    super();
+  }
 }
 
-/**
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
- */
-declare class PrivilegedServices {
-  /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-  static Codec = codec.Class(PrivilegedServices, {
-    manager: codec.u32.asOpaque<ServiceId>(),
-    assigners: codecPerCore(codec.u32.asOpaque<ServiceId>()),
-    delegator: codec.u32.asOpaque<ServiceId>(),
-    registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-      ? codec.u32.asOpaque<ServiceId>()
-      : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-    autoAccumulateServices: readonlyArray(codec.sequenceVarLen(AutoAccumulate.Codec)),
+declare class SafroleData {
+  static Codec = codec.Class(SafroleData, {
+    nextValidatorData: codecPerValidator(ValidatorData.Codec),
+    epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque<BandersnatchRingRoot>(),
+    sealingKeySeries: SafroleSealingKeysData.Codec,
+    ticketsAccumulator: readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
   });
 
-  static create(a: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+  static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
+    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
   }
 
   private 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
-     */
-    readonly manager: ServiceId,
-    /** `χ_V`: Managers validator keys. */
-    readonly delegator: ServiceId,
-    /**
-     * `χ_R`: Manages the creation of services in protected range.
-     *
-     * https://graypaper.fluffylabs.dev/#/ab2cdbd/111b02111d02?v=0.7.2
-     */
-    readonly registrar: ServiceId,
-    /** `χ_A`: Manages authorization queue one for each core. */
-    readonly assigners: PerCore<ServiceId>,
-    /** `χ_Z`: Dictionary of services that auto-accumulate every block with their gas limit. */
-    readonly autoAccumulateServices: readonly AutoAccumulate[],
+    /** gamma_k */
+    public readonly nextValidatorData: PerValidator<ValidatorData>,
+    /** gamma_z */
+    public readonly epochRoot: BandersnatchRingRoot,
+    /** gamma_s */
+    public readonly sealingKeySeries: SafroleSealingKeys,
+    /** gamma_a */
+    public readonly ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">,
   ) {}
 }
 
@@ -10319,8 +10289,6 @@ declare class StatisticsData {
   ) {}
 }
 
-type StatisticsDataView = DescribedBy<typeof StatisticsData.Codec.View>;
-
 /**
  * In addition to the entropy accumulator η_0, we retain
  * three additional historical values of the accumulator at
@@ -10372,7 +10340,7 @@ type State = {
   /**
    * `γₖ gamma_k`: The keys for the validators of the next epoch, equivalent to those keys which constitute γ_z .
    */
-  readonly nextValidatorData: PerValidator<ValidatorData>;
+  readonly nextValidatorData: SafroleData["nextValidatorData"];
 
   /**
    * `κ kappa`: Validators, who are the set of economic actors uniquely
@@ -10418,7 +10386,7 @@ type State = {
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authPools: PerCore<AuthorizationPool>;
+  readonly authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
 
   /**
    * `φ phi`: A queue of authorizers for each core used to fill up the pool.
@@ -10427,14 +10395,14 @@ type State = {
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authQueues: PerCore<AuthorizationQueue>;
+  readonly authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
 
   /**
    * `β beta`: State of the blocks from recent history.
    *
    * https://graypaper.fluffylabs.dev/#/579bd12/0fb7010fb701
    */
-  readonly recentBlocks: RecentBlocks;
+  readonly recentBlocks: RecentBlocksHistory;
 
   /**
    * `π pi`: Previous and current statistics of each validator,
@@ -10451,7 +10419,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/165300165500
    */
-  readonly accumulationQueue: AccumulationQueue;
+  readonly accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
 
   /**
    * `ξ xi`: In order to know which work-packages have been
@@ -10461,7 +10429,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/161a00161d00
    */
-  readonly recentlyAccumulated: RecentlyAccumulated;
+  readonly recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
 
   /*
    * `γₐ gamma_a`: The ticket accumulator - a series of highest-scoring ticket identifiers to be
@@ -10534,113 +10502,6 @@ interface Service {
   getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null;
 }
 
-/** Additional marker interface, when state view is supported/required. */
-type WithStateView<V = StateView> = {
-  /** Get view of the state. */
-  view(): V;
-};
-
-/**
- * A non-decoding version of the `State`.
- *
- * Note we don't require all fields to have view accessors, since
- * it's only beneficial for large collections to be read via views.
- *
- * https://graypaper.fluffylabs.dev/#/579bd12/08f10008f100
- */
-type StateView = {
-  /**
-
-   * `ρ rho`: work-reports which have been reported but are not yet known to be
-   *          available to a super-majority of validators, together with the time
-   *          at which each was reported.
-   *
-   *  https://graypaper.fluffylabs.dev/#/579bd12/135800135800
-   */
-  availabilityAssignmentView(): AvailabilityAssignmentsView;
-
-  /**
-   * `ι iota`: The validator keys and metadata to be drawn from next.
-   */
-  designatedValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
-
-  /**
-   * `κ kappa`: Validators, who are the set of economic actors uniquely
-   *            privileged to help build and maintain the Jam chain, are
-   *            identified within κ, archived in λ and enqueued from ι.
-   *
-   *  https://graypaper.fluffylabs.dev/#/579bd12/080201080601
-   */
-  currentValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
-
-  /**
-   * `λ lambda`: Validators, who are the set of economic actors uniquely
-   *             privileged to help build and maintain the Jam chain, are
-   *             identified within κ, archived in λ and enqueued from ι.
-   *
-   *  https://graypaper.fluffylabs.dev/#/579bd12/080201080601
-   */
-  previousValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView>;
-
-  /**
-   * `α alpha`: Authorizers available for each core (authorizer pool).
-   *
-   * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
-   */
-  authPoolsView(): SequenceView<AuthorizationPool, SequenceView<AuthorizerHash>>;
-
-  /**
-   * `φ phi`: A queue of authorizers for each core used to fill up the pool.
-   *
-   * Only updated by `accumulate` calls using `assign` host call.
-   *
-   * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
-   */
-  authQueuesView(): SequenceView<AuthorizationQueue, SequenceView<AuthorizerHash>>;
-
-  /**
-   * `β beta`: State of the blocks from recent history.
-   *
-   * https://graypaper.fluffylabs.dev/#/579bd12/0fb7010fb701
-   */
-  recentBlocksView(): RecentBlocksView;
-
-  /**
-   * `π pi`: Previous and current statistics of each validator,
-   *         cores statistics and services statistics.
-   *
-   * https://graypaper.fluffylabs.dev/#/68eaa1f/18f60118f601?v=0.6.4
-   */
-  statisticsView(): StatisticsDataView;
-
-  /**
-   * `ϑ theta`: We also maintain knowledge of ready (i.e. available
-   * and/or audited) but not-yet-accumulated work-reports in
-   * the state item ϑ.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/165300165500
-   */
-  accumulationQueueView(): AccumulationQueueView;
-
-  /**
-   * `ξ xi`: In order to know which work-packages have been
-   * accumulated already, we maintain a history of what has
-   * been accumulated. This history, ξ, is sufficiently large
-   * for an epoch worth of work-reports.
-   *
-   * https://graypaper.fluffylabs.dev/#/5f542d7/161a00161d00
-   */
-  recentlyAccumulatedView(): RecentlyAccumulatedView;
-
-  /*
-   * `γ gamma`: Safrole data.
-   */
-  safroleDataView(): SafroleDataView;
-
-  /** Retrieve details about single service. */
-  getServiceInfoView(id: ServiceId): ServiceAccountInfoView | null;
-};
-
 declare enum UpdatePreimageKind {
   /** Insert new preimage and optionally update it's lookup history. */
   Provide = 0,
@@ -10963,10 +10824,10 @@ declare class InMemoryService extends WithDebug implements Service {
 /**
  * A special version of state, stored fully in-memory.
  */
-declare class InMemoryState extends WithDebug implements State, WithStateView, EnumerableState {
+declare class InMemoryState extends WithDebug implements State, EnumerableState {
   /** Create a new `InMemoryState` by providing all required fields. */
-  static new(chainSpec: ChainSpec, state: InMemoryStateFields) {
-    return new InMemoryState(chainSpec, state);
+  static create(state: InMemoryStateFields) {
+    return new InMemoryState(state);
   }
 
   /**
@@ -10984,7 +10845,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
   /**
    * Create a new `InMemoryState` from some other state object.
    */
-  static copyFrom(chainSpec: ChainSpec, other: State, servicesData: Map<ServiceId, ServiceEntries>) {
+  static copyFrom(other: State, servicesData: Map<ServiceId, ServiceEntries>) {
     const services = new Map<ServiceId, InMemoryService>();
     for (const [id, entries] of servicesData.entries()) {
       const service = other.getService(id);
@@ -10995,7 +10856,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
       services.set(id, inMemService);
     }
 
-    return InMemoryState.new(chainSpec, {
+    return InMemoryState.create({
       availabilityAssignment: other.availabilityAssignment,
       accumulationQueue: other.accumulationQueue,
       designatedValidatorData: other.designatedValidatorData,
@@ -11190,12 +11051,12 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
   disputesRecords: DisputesRecords;
   timeslot: TimeSlot;
   entropy: FixedSizeArray<EntropyHash, ENTROPY_ENTRIES>;
-  authPools: PerCore<AuthorizationPool>;
-  authQueues: PerCore<AuthorizationQueue>;
-  recentBlocks: RecentBlocks;
+  authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
+  authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
+  recentBlocks: RecentBlocksHistory;
   statistics: StatisticsData;
-  accumulationQueue: AccumulationQueue;
-  recentlyAccumulated: RecentlyAccumulated;
+  accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
+  recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
   ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">;
   sealingKeySeries: SafroleSealingKeys;
   epochRoot: BandersnatchRingRoot;
@@ -11211,10 +11072,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
     return this.services.get(id) ?? null;
   }
 
-  protected constructor(
-    private readonly chainSpec: ChainSpec,
-    s: InMemoryStateFields,
-  ) {
+  private constructor(s: InMemoryStateFields) {
     super();
     this.availabilityAssignment = s.availabilityAssignment;
     this.designatedValidatorData = s.designatedValidatorData;
@@ -11238,15 +11096,11 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
     this.services = s.services;
   }
 
-  view(): StateView {
-    return new InMemoryStateView(this.chainSpec, this);
-  }
-
   /**
    * Create an empty and possibly incoherent `InMemoryState`.
    */
   static empty(spec: ChainSpec) {
-    return new InMemoryState(spec, {
+    return new InMemoryState({
       availabilityAssignment: tryAsPerCore(
         Array.from({ length: spec.coresCount }, () => null),
         spec,
@@ -11313,7 +11167,7 @@ declare class InMemoryState extends WithDebug implements State, WithStateView, E
         ),
         spec,
       ),
-      recentBlocks: RecentBlocks.empty(),
+      recentBlocks: RecentBlocksHistory.empty(),
       statistics: StatisticsData.create({
         current: tryAsPerValidator(
           Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()),
@@ -11399,18 +11253,12 @@ type FieldNames<T> = {
   [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T];
 
-type index$e_AUTHORIZATION_QUEUE_SIZE = AUTHORIZATION_QUEUE_SIZE;
 type index$e_AccumulationOutput = AccumulationOutput;
 declare const index$e_AccumulationOutput: typeof AccumulationOutput;
-type index$e_AccumulationQueue = AccumulationQueue;
-type index$e_AccumulationQueueView = AccumulationQueueView;
-type index$e_AuthorizationPool = AuthorizationPool;
-type index$e_AuthorizationQueue = AuthorizationQueue;
 type index$e_AutoAccumulate = AutoAccumulate;
 declare const index$e_AutoAccumulate: typeof AutoAccumulate;
 type index$e_AvailabilityAssignment = AvailabilityAssignment;
 declare const index$e_AvailabilityAssignment: typeof AvailabilityAssignment;
-type index$e_AvailabilityAssignmentsView = AvailabilityAssignmentsView;
 declare const index$e_BASE_SERVICE_BALANCE: typeof BASE_SERVICE_BALANCE;
 type index$e_BlockState = BlockState;
 declare const index$e_BlockState: typeof BlockState;
@@ -11432,11 +11280,8 @@ type index$e_InMemoryStateFields = InMemoryStateFields;
 type index$e_LookupHistoryItem = LookupHistoryItem;
 declare const index$e_LookupHistoryItem: typeof LookupHistoryItem;
 type index$e_LookupHistorySlots = LookupHistorySlots;
-type index$e_MAX_AUTH_POOL_SIZE = MAX_AUTH_POOL_SIZE;
 declare const index$e_MAX_LOOKUP_HISTORY_SLOTS: typeof MAX_LOOKUP_HISTORY_SLOTS;
 type index$e_MAX_RECENT_HISTORY = MAX_RECENT_HISTORY;
-type index$e_NotYetAccumulatedReport = NotYetAccumulatedReport;
-declare const index$e_NotYetAccumulatedReport: typeof NotYetAccumulatedReport;
 type index$e_PerCore<T> = PerCore<T>;
 type index$e_PreimageItem = PreimageItem;
 declare const index$e_PreimageItem: typeof PreimageItem;
@@ -11444,12 +11289,10 @@ type index$e_PrivilegedServices = PrivilegedServices;
 declare const index$e_PrivilegedServices: typeof PrivilegedServices;
 type index$e_RecentBlocks = RecentBlocks;
 declare const index$e_RecentBlocks: typeof RecentBlocks;
-type index$e_RecentBlocksView = RecentBlocksView;
-type index$e_RecentlyAccumulated = RecentlyAccumulated;
-type index$e_RecentlyAccumulatedView = RecentlyAccumulatedView;
+type index$e_RecentBlocksHistory = RecentBlocksHistory;
+declare const index$e_RecentBlocksHistory: typeof RecentBlocksHistory;
 type index$e_SafroleData = SafroleData;
 declare const index$e_SafroleData: typeof SafroleData;
-type index$e_SafroleDataView = SafroleDataView;
 type index$e_SafroleSealingKeys = SafroleSealingKeys;
 type index$e_SafroleSealingKeysData = SafroleSealingKeysData;
 declare const index$e_SafroleSealingKeysData: typeof SafroleSealingKeysData;
@@ -11458,17 +11301,14 @@ declare const index$e_SafroleSealingKeysKind: typeof SafroleSealingKeysKind;
 type index$e_Service = Service;
 type index$e_ServiceAccountInfo = ServiceAccountInfo;
 declare const index$e_ServiceAccountInfo: typeof ServiceAccountInfo;
-type index$e_ServiceAccountInfoView = ServiceAccountInfoView;
 type index$e_ServiceData = ServiceData;
 type index$e_ServiceEntries = ServiceEntries;
 type index$e_ServiceStatistics = ServiceStatistics;
 declare const index$e_ServiceStatistics: typeof ServiceStatistics;
 type index$e_ServicesUpdate = ServicesUpdate;
 type index$e_State = State;
-type index$e_StateView = StateView;
 type index$e_StatisticsData = StatisticsData;
 declare const index$e_StatisticsData: typeof StatisticsData;
-type index$e_StatisticsDataView = StatisticsDataView;
 type index$e_StorageItem = StorageItem;
 declare const index$e_StorageItem: typeof StorageItem;
 type index$e_StorageKey = StorageKey;
@@ -11489,15 +11329,9 @@ declare const index$e_UpdateStorageKind: typeof UpdateStorageKind;
 type index$e_VALIDATOR_META_BYTES = VALIDATOR_META_BYTES;
 type index$e_ValidatorData = ValidatorData;
 declare const index$e_ValidatorData: typeof ValidatorData;
-type index$e_ValidatorDataView = ValidatorDataView;
 type index$e_ValidatorStatistics = ValidatorStatistics;
 declare const index$e_ValidatorStatistics: typeof ValidatorStatistics;
-type index$e_WithStateView<V = StateView> = WithStateView<V>;
 declare const index$e_accumulationOutputComparator: typeof accumulationOutputComparator;
-declare const index$e_accumulationQueueCodec: typeof accumulationQueueCodec;
-declare const index$e_authPoolsCodec: typeof authPoolsCodec;
-declare const index$e_authQueuesCodec: typeof authQueuesCodec;
-declare const index$e_availabilityAssignmentsCodec: typeof availabilityAssignmentsCodec;
 declare const index$e_codecBandersnatchKey: typeof codecBandersnatchKey;
 declare const index$e_codecPerCore: typeof codecPerCore;
 declare const index$e_codecServiceId: typeof codecServiceId;
@@ -11506,18 +11340,16 @@ declare const index$e_codecVarU16: typeof codecVarU16;
 declare const index$e_codecWithVersion: typeof codecWithVersion;
 declare const index$e_hashComparator: typeof hashComparator;
 declare const index$e_ignoreValueWithDefault: typeof ignoreValueWithDefault;
-declare const index$e_recentlyAccumulatedCodec: typeof recentlyAccumulatedCodec;
 declare const index$e_serviceDataCodec: typeof serviceDataCodec;
 declare const index$e_serviceEntriesCodec: typeof serviceEntriesCodec;
 declare const index$e_sortedSetCodec: typeof sortedSetCodec;
 declare const index$e_tryAsLookupHistorySlots: typeof tryAsLookupHistorySlots;
 declare const index$e_tryAsPerCore: typeof tryAsPerCore;
-declare const index$e_validatorsDataCodec: typeof validatorsDataCodec;
 declare const index$e_workReportsSortedSetCodec: typeof workReportsSortedSetCodec;
 declare const index$e_zeroSizeHint: typeof zeroSizeHint;
 declare namespace index$e {
-  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_NotYetAccumulatedReport as NotYetAccumulatedReport, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_accumulationQueueCodec as accumulationQueueCodec, index$e_authPoolsCodec as authPoolsCodec, index$e_authQueuesCodec as authQueuesCodec, index$e_availabilityAssignmentsCodec as availabilityAssignmentsCodec, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_recentlyAccumulatedCodec as recentlyAccumulatedCodec, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_validatorsDataCodec as validatorsDataCodec, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
-  export type { index$e_AUTHORIZATION_QUEUE_SIZE as AUTHORIZATION_QUEUE_SIZE, index$e_AccumulationQueue as AccumulationQueue, index$e_AccumulationQueueView as AccumulationQueueView, index$e_AuthorizationPool as AuthorizationPool, index$e_AuthorizationQueue as AuthorizationQueue, index$e_AvailabilityAssignmentsView as AvailabilityAssignmentsView, index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_AUTH_POOL_SIZE as MAX_AUTH_POOL_SIZE, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_RecentBlocksView as RecentBlocksView, index$e_RecentlyAccumulated as RecentlyAccumulated, index$e_RecentlyAccumulatedView as RecentlyAccumulatedView, index$e_SafroleDataView as SafroleDataView, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceAccountInfoView as ServiceAccountInfoView, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StateView as StateView, index$e_StatisticsDataView as StatisticsDataView, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES, index$e_ValidatorDataView as ValidatorDataView, index$e_WithStateView as WithStateView };
+  export { index$e_AccumulationOutput as AccumulationOutput, index$e_AutoAccumulate as AutoAccumulate, index$e_AvailabilityAssignment as AvailabilityAssignment, index$e_BASE_SERVICE_BALANCE as BASE_SERVICE_BALANCE, index$e_BlockState as BlockState, index$e_CoreStatistics as CoreStatistics, index$e_DisputesRecords as DisputesRecords, index$e_ELECTIVE_BYTE_BALANCE as ELECTIVE_BYTE_BALANCE, index$e_ELECTIVE_ITEM_BALANCE as ELECTIVE_ITEM_BALANCE, index$e_InMemoryService as InMemoryService, index$e_InMemoryState as InMemoryState, index$e_LookupHistoryItem as LookupHistoryItem, index$e_MAX_LOOKUP_HISTORY_SLOTS as MAX_LOOKUP_HISTORY_SLOTS, index$e_PreimageItem as PreimageItem, index$e_PrivilegedServices as PrivilegedServices, index$e_RecentBlocks as RecentBlocks, index$e_RecentBlocksHistory as RecentBlocksHistory, index$e_SafroleData as SafroleData, index$e_SafroleSealingKeysData as SafroleSealingKeysData, index$e_SafroleSealingKeysKind as SafroleSealingKeysKind, index$e_ServiceAccountInfo as ServiceAccountInfo, index$e_ServiceStatistics as ServiceStatistics, index$e_StatisticsData as StatisticsData, index$e_StorageItem as StorageItem, index$e_UpdateError as UpdateError, index$e_UpdatePreimage as UpdatePreimage, index$e_UpdatePreimageKind as UpdatePreimageKind, index$e_UpdateService as UpdateService, index$e_UpdateServiceKind as UpdateServiceKind, index$e_UpdateStorage as UpdateStorage, index$e_UpdateStorageKind as UpdateStorageKind, index$e_ValidatorData as ValidatorData, index$e_ValidatorStatistics as ValidatorStatistics, index$e_accumulationOutputComparator as accumulationOutputComparator, index$e_codecBandersnatchKey as codecBandersnatchKey, index$e_codecPerCore as codecPerCore, index$e_codecServiceId as codecServiceId, index$e_codecVarGas as codecVarGas, index$e_codecVarU16 as codecVarU16, index$e_codecWithVersion as codecWithVersion, index$e_hashComparator as hashComparator, index$e_ignoreValueWithDefault as ignoreValueWithDefault, index$e_serviceDataCodec as serviceDataCodec, index$e_serviceEntriesCodec as serviceEntriesCodec, index$e_sortedSetCodec as sortedSetCodec, index$e_tryAsLookupHistorySlots as tryAsLookupHistorySlots, index$e_tryAsPerCore as tryAsPerCore, index$e_workReportsSortedSetCodec as workReportsSortedSetCodec, index$e_zeroSizeHint as zeroSizeHint };
+  export type { index$e_BlocksState as BlocksState, index$e_ENTROPY_ENTRIES as ENTROPY_ENTRIES, index$e_EnumerableState as EnumerableState, index$e_FieldNames as FieldNames, index$e_InMemoryStateFields as InMemoryStateFields, index$e_LookupHistorySlots as LookupHistorySlots, index$e_MAX_RECENT_HISTORY as MAX_RECENT_HISTORY, index$e_PerCore as PerCore, index$e_SafroleSealingKeys as SafroleSealingKeys, index$e_Service as Service, index$e_ServiceData as ServiceData, index$e_ServiceEntries as ServiceEntries, index$e_ServicesUpdate as ServicesUpdate, index$e_State as State, index$e_StorageKey as StorageKey, index$e_VALIDATOR_META_BYTES as VALIDATOR_META_BYTES };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -11658,25 +11490,33 @@ declare function legacyServiceNested(serviceId: ServiceId, hash: OpaqueHash): St
   return key.asOpaque();
 }
 
-type StateCodec<T, V = T> = {
+type StateCodec<T> = {
   key: StateKey;
-  Codec: Descriptor<T, V>;
+  Codec: Descriptor<T>;
   extract: (s: State) => T;
 };
 
 /** Serialization for particular state entries. */
 declare namespace serialize {
   /** C(1): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b15013b1501?v=0.6.7 */
-  export const authPools: StateCodec<State["authPools"], ReturnType<StateView["authPoolsView"]>> = {
+  export const authPools: StateCodec<State["authPools"]> = {
     key: stateKeys.index(StateKeyIdx.Alpha),
-    Codec: authPoolsCodec,
+    Codec: codecPerCore(
+      codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), {
+        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 */
-  export const authQueues: StateCodec<State["authQueues"], ReturnType<StateView["authQueuesView"]>> = {
+  export const authQueues: StateCodec<State["authQueues"]> = {
     key: stateKeys.index(StateKeyIdx.Phi),
-    Codec: authQueuesCodec,
+    Codec: codecPerCore(
+      codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), AUTHORIZATION_QUEUE_SIZE),
+    ),
     extract: (s) => s.authQueues,
   };
 
@@ -11684,14 +11524,14 @@ declare namespace serialize {
    * C(3): Recent blocks with compatibility
    *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
    */
-  export const recentBlocks: StateCodec<RecentBlocks, RecentBlocksView> = {
+  export const recentBlocks: StateCodec<State["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 */
-  export const safrole: StateCodec<SafroleData, SafroleDataView> = {
+  export const safrole: StateCodec<SafroleData> = {
     key: stateKeys.index(StateKeyIdx.Gamma),
     Codec: SafroleData.Codec,
     extract: (s) =>
@@ -11704,7 +11544,7 @@ declare namespace serialize {
   };
 
   /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
-  export const disputesRecords: StateCodec<DisputesRecords> = {
+  export const disputesRecords: StateCodec<State["disputesRecords"]> = {
     key: stateKeys.index(StateKeyIdx.Psi),
     Codec: DisputesRecords.Codec,
     extract: (s) => s.disputesRecords,
@@ -11718,42 +11558,30 @@ declare namespace serialize {
   };
 
   /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
-  export const designatedValidators: StateCodec<
-    State["designatedValidatorData"],
-    ReturnType<StateView["designatedValidatorDataView"]>
-  > = {
+  export const designatedValidators: StateCodec<State["designatedValidatorData"]> = {
     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 */
-  export const currentValidators: StateCodec<
-    State["currentValidatorData"],
-    ReturnType<StateView["currentValidatorDataView"]>
-  > = {
+  export const currentValidators: StateCodec<State["currentValidatorData"]> = {
     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 */
-  export const previousValidators: StateCodec<
-    State["previousValidatorData"],
-    ReturnType<StateView["previousValidatorDataView"]>
-  > = {
+  export const previousValidators: StateCodec<State["previousValidatorData"]> = {
     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 */
-  export const availabilityAssignment: StateCodec<
-    State["availabilityAssignment"],
-    ReturnType<StateView["availabilityAssignmentView"]>
-  > = {
+  export const availabilityAssignment: StateCodec<State["availabilityAssignment"]> = {
     key: stateKeys.index(StateKeyIdx.Rho),
-    Codec: availabilityAssignmentsCodec,
+    Codec: codecPerCore(codec.optional(AvailabilityAssignment.Codec)),
     extract: (s) => s.availabilityAssignment,
   };
 
@@ -11772,29 +11600,28 @@ declare namespace serialize {
   };
 
   /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
-  export const statistics: StateCodec<StatisticsData, StatisticsDataView> = {
+  export const statistics: StateCodec<State["statistics"]> = {
     key: stateKeys.index(StateKeyIdx.Pi),
     Codec: StatisticsData.Codec,
     extract: (s) => s.statistics,
   };
 
   /** C(14): https://graypaper.fluffylabs.dev/#/1c979cb/3bf0023bf002?v=0.7.1 */
-  export const accumulationQueue: StateCodec<
-    State["accumulationQueue"],
-    ReturnType<StateView["accumulationQueueView"]>
-  > = {
+  export const accumulationQueue: StateCodec<State["accumulationQueue"]> = {
     key: stateKeys.index(StateKeyIdx.Omega),
-    Codec: accumulationQueueCodec,
+    Codec: codecPerEpochBlock(readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec))),
     extract: (s) => s.accumulationQueue,
   };
 
   /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
-  export const recentlyAccumulated: StateCodec<
-    State["recentlyAccumulated"],
-    ReturnType<StateView["recentlyAccumulatedView"]>
-  > = {
+  export const recentlyAccumulated: StateCodec<State["recentlyAccumulated"]> = {
     key: stateKeys.index(StateKeyIdx.Xi),
-    Codec: recentlyAccumulatedCodec,
+    Codec: codecPerEpochBlock(
+      codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>()).convert(
+        (x) => Array.from(x),
+        (x) => HashSet.from(x),
+      ),
+    ),
     extract: (s) => s.recentlyAccumulated,
   };
 
@@ -11850,107 +11677,6 @@ declare const dumpCodec = Descriptor.new<BytesBlob>(
   (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()),
 );
 
-/**
- * Abstraction over some backend containing serialized state entries.
- *
- * This may or may not be backed by some on-disk database or can be just stored in memory.
- */
-interface SerializedStateBackend {
-  /** Retrieve given state key. */
-  get(key: StateKey): BytesBlob | null;
-}
-
-declare class SerializedStateView<T extends SerializedStateBackend> implements StateView {
-  constructor(
-    private readonly spec: ChainSpec,
-    public backend: T,
-    /** Best-effort list of recently active services. */
-    private readonly recentlyUsedServices: ServiceId[],
-    private readonly viewCache: HashDictionary<StateKey, unknown>,
-  ) {}
-
-  private retrieveView<A, B>({ key, Codec }: KeyAndCodecWithView<A, B>, description: string): B {
-    const cached = this.viewCache.get(key);
-    if (cached !== undefined) {
-      return cached as B;
-    }
-    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(): AvailabilityAssignmentsView {
-    return this.retrieveView(serialize.availabilityAssignment, "availabilityAssignmentView");
-  }
-
-  designatedValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
-    return this.retrieveView(serialize.designatedValidators, "designatedValidatorsView");
-  }
-
-  currentValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
-    return this.retrieveView(serialize.currentValidators, "currentValidatorsView");
-  }
-
-  previousValidatorDataView(): SequenceView<ValidatorData, ValidatorDataView> {
-    return this.retrieveView(serialize.previousValidators, "previousValidatorsView");
-  }
-
-  authPoolsView(): SequenceView<AuthorizationPool, SequenceView<AuthorizerHash>> {
-    return this.retrieveView(serialize.authPools, "authPoolsView");
-  }
-
-  authQueuesView(): SequenceView<AuthorizationQueue, SequenceView<AuthorizerHash>> {
-    return this.retrieveView(serialize.authQueues, "authQueuesView");
-  }
-
-  recentBlocksView(): RecentBlocksView {
-    return this.retrieveView(serialize.recentBlocks, "recentBlocksView");
-  }
-
-  statisticsView(): StatisticsDataView {
-    return this.retrieveView(serialize.statistics, "statisticsView");
-  }
-
-  accumulationQueueView(): AccumulationQueueView {
-    return this.retrieveView(serialize.accumulationQueue, "accumulationQueueView");
-  }
-
-  recentlyAccumulatedView(): RecentlyAccumulatedView {
-    return this.retrieveView(serialize.recentlyAccumulated, "recentlyAccumulatedView");
-  }
-
-  safroleDataView(): SafroleDataView {
-    return this.retrieveView(serialize.safrole, "safroleDataView");
-  }
-
-  getServiceInfoView(id: ServiceId): ServiceAccountInfoView | null {
-    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);
-  }
-}
-
-type KeyAndCodecWithView<T, V> = {
-  key: StateKey;
-  Codec: CodecWithView<T, V>;
-};
-
 /** What should be done with that key? */
 declare enum StateEntryUpdateAction {
   /** Insert an entry. */
@@ -12329,6 +12055,16 @@ declare function convertInMemoryStateToDictionary(
   return serialized;
 }
 
+/**
+ * Abstraction over some backend containing serialized state entries.
+ *
+ * This may or may not be backed by some on-disk database or can be just stored in memory.
+ */
+interface SerializedStateBackend {
+  /** Retrieve given state key. */
+  get(key: StateKey): BytesBlob | null;
+}
+
 /**
  * State object which reads it's entries from some backend.
  *
@@ -12338,7 +12074,7 @@ declare function convertInMemoryStateToDictionary(
  * in the backend layer, so it MAY fail during runtime.
  */
 declare class SerializedState<T extends SerializedStateBackend = SerializedStateBackend>
-  implements State, WithStateView, EnumerableState
+  implements State, EnumerableState
 {
   /** Create a state-like object from collection of serialized entries. */
   static fromStateEntries(spec: ChainSpec, blake2b: Blake2b, state: StateEntries, recentServices: ServiceId[] = []) {
@@ -12355,15 +12091,12 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
     return new SerializedState(spec, blake2b, db, recentServices);
   }
 
-  private dataCache: HashDictionary<StateKey, unknown> = HashDictionary.new();
-  private viewCache: HashDictionary<StateKey, unknown> = HashDictionary.new();
-
   private constructor(
     private readonly spec: ChainSpec,
     private readonly blake2b: Blake2b,
     public backend: T,
     /** Best-effort list of recently active services. */
-    private readonly recentlyUsedServices: ServiceId[],
+    private readonly _recentServiceIds: ServiceId[],
   ) {}
 
   /** Comparing the serialized states, just means comparing their backends. */
@@ -12371,21 +12104,14 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
     return this.backend;
   }
 
-  /** Return a non-decoding version of the state. */
-  view(): StateView {
-    return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
-  }
-
   // TODO [ToDr] Temporary method to update the state,
   // without changing references.
   public updateBackend(newBackend: T) {
     this.backend = newBackend;
-    this.dataCache = HashDictionary.new();
-    this.viewCache = HashDictionary.new();
   }
 
   recentServiceIds(): readonly ServiceId[] {
-    return this.recentlyUsedServices;
+    return this._recentServiceIds;
   }
 
   getService(id: ServiceId): SerializedService | null {
@@ -12394,33 +12120,27 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
       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));
   }
 
-  private retrieve<T>(k: KeyAndCodec<T>, description: string): T {
-    const data = this.retrieveOptional(k);
-    if (data === undefined) {
-      throw new Error(`Required state entry for ${description} is missing!. Accessing key: ${k.key}`);
+  private retrieve<T>({ key, Codec }: KeyAndCodec<T>, description: string): T {
+    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);
   }
 
   private retrieveOptional<T>({ key, Codec }: KeyAndCodec<T>): T | undefined {
-    const cached = this.dataCache.get(key);
-    if (cached !== undefined) {
-      return cached as T;
-    }
     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(): State["availabilityAssignment"] {
@@ -12593,15 +12313,12 @@ declare function loadState(spec: ChainSpec, blake2b: Blake2b, entries: Iterable<
 declare const index$d_EMPTY_BLOB: typeof EMPTY_BLOB;
 type index$d_EncodeFun = EncodeFun;
 type index$d_KeyAndCodec<T> = KeyAndCodec<T>;
-type index$d_KeyAndCodecWithView<T, V> = KeyAndCodecWithView<T, V>;
 type index$d_SerializedService = SerializedService;
 declare const index$d_SerializedService: typeof SerializedService;
 type index$d_SerializedState<T extends SerializedStateBackend = SerializedStateBackend> = SerializedState<T>;
 declare const index$d_SerializedState: typeof SerializedState;
 type index$d_SerializedStateBackend = SerializedStateBackend;
-type index$d_SerializedStateView<T extends SerializedStateBackend> = SerializedStateView<T>;
-declare const index$d_SerializedStateView: typeof SerializedStateView;
-type index$d_StateCodec<T, V = T> = StateCodec<T, V>;
+type index$d_StateCodec<T> = StateCodec<T>;
 type index$d_StateEntries = StateEntries;
 declare const index$d_StateEntries: typeof StateEntries;
 type index$d_StateEntryUpdate = StateEntryUpdate;
@@ -12629,8 +12346,8 @@ declare const index$d_serializeStorage: typeof serializeStorage;
 declare const index$d_stateEntriesSequenceCodec: typeof stateEntriesSequenceCodec;
 import index$d_stateKeys = stateKeys;
 declare namespace index$d {
-  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_SerializedStateView as SerializedStateView, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
-  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_KeyAndCodecWithView as KeyAndCodecWithView, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
+  export { index$d_EMPTY_BLOB as EMPTY_BLOB, index$d_SerializedService as SerializedService, index$d_SerializedState as SerializedState, index$d_StateEntries as StateEntries, index$d_StateEntryUpdateAction as StateEntryUpdateAction, index$d_StateKeyIdx as StateKeyIdx, index$d_TYPICAL_STATE_ITEMS as TYPICAL_STATE_ITEMS, index$d_TYPICAL_STATE_ITEM_LEN as TYPICAL_STATE_ITEM_LEN, index$d_U32_BYTES as U32_BYTES, index$d_binaryMerkleization as binaryMerkleization, index$d_convertInMemoryStateToDictionary as convertInMemoryStateToDictionary, index$d_dumpCodec as dumpCodec, index$d_getSafroleData as getSafroleData, index$d_legacyServiceNested as legacyServiceNested, index$d_loadState as loadState, index$d_serialize as serialize, index$d_serializeBasicKeys as serializeBasicKeys, index$d_serializePreimages as serializePreimages, index$d_serializeRemovedServices as serializeRemovedServices, index$d_serializeServiceUpdates as serializeServiceUpdates, index$d_serializeStateUpdate as serializeStateUpdate, index$d_serializeStorage as serializeStorage, index$d_stateEntriesSequenceCodec as stateEntriesSequenceCodec, index$d_stateKeys as stateKeys };
+  export type { index$d_EncodeFun as EncodeFun, index$d_KeyAndCodec as KeyAndCodec, index$d_SerializedStateBackend as SerializedStateBackend, index$d_StateCodec as StateCodec, index$d_StateEntryUpdate as StateEntryUpdate, index$d_StateKey as StateKey };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12825,7 +12542,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
 
   /** Insert a full state into the database. */
   async insertState(headerHash: HeaderHash, state: InMemoryState): Promise<Result$2<OK, StateUpdateError>> {
-    const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
+    const encoded = Encoder.encodeObject(inMemoryStateCodec, state, this.spec);
     this.db.set(headerHash, encoded);
     return Result.ok(OK);
   }
@@ -12836,7 +12553,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
       return null;
     }
 
-    return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
+    return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
   }
 }
 
@@ -14098,8 +13815,8 @@ interface PartialState {
   /** Update authorization queue for given core and authorize a service for this core. */
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
-    authQueue: AuthorizationQueue,
-    assigner: ServiceId | null,
+    authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
+    assigners: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -19564,7 +19281,7 @@ type JsonRecentBlockState = {
   reported: WorkPackageInfo[];
 };
 
-declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocks>(
+declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocksHistory>(
   {
     history: json.array(recentBlockStateFromJson),
     mmr: {
@@ -19572,10 +19289,12 @@ declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, Recent
     },
   },
   ({ history, mmr }) => {
-    return RecentBlocks.create({
-      blocks: history,
-      accumulationLog: mmr,
-    });
+    return RecentBlocksHistory.create(
+      RecentBlocks.create({
+        blocks: history,
+        accumulationLog: mmr,
+      }),
+    );
   },
 );
 
@@ -19887,7 +19606,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
       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) {
@@ -19906,7 +19625,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           }),
           spec,
         ),
-        recentBlocks: beta ?? RecentBlocks.empty(),
+        recentBlocks: beta ?? RecentBlocksHistory.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -20011,25 +19730,23 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
    */
   extrinsic(extrinsicView: ExtrinsicView): WithHashAndBytes<ExtrinsicHash, ExtrinsicView> {
     // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-    const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
-    const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
-    const guaranteesBlobs = extrinsicView.guarantees
+    const guarantees = extrinsicView.guarantees
       .view()
       .map((g) => g.view())
-      .reduce(
-        (aggregated, guarantee) => {
-          const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque<WorkReportHash>();
-          aggregated.push(reportHash.raw);
-          aggregated.push(guarantee.slot.encoded().raw);
-          aggregated.push(guarantee.credentials.encoded().raw);
-          return aggregated;
-        },
-        [countEncoded.raw],
-      );
+      .map((guarantee) => {
+        const reportHash = this.blake2b.hashBytes(guarantee.report.encoded()).asOpaque<WorkReportHash>();
+        return BytesBlob.blobFromParts([
+          reportHash.raw,
+          guarantee.slot.encoded().raw,
+          guarantee.credentials.encoded().raw,
+        ]);
+      });
+
+    const guaranteeBlob = Encoder.encodeObject(codec.sequenceVarLen(dumpCodec), guarantees, this.context);
 
     const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque<ExtrinsicHash>();
     const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque<ExtrinsicHash>();
-    const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque<ExtrinsicHash>();
+    const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque<ExtrinsicHash>();
     const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque<ExtrinsicHash>();
     const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque<ExtrinsicHash>();