@typeberry/lib 0.2.0-b6e3410 → 0.2.0-e767e74

package/index.d.ts

@@ -2427,11 +2427,15 @@ 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.
  *
@@ -2440,7 +2444,7 @@ type Codec<T> = Encode<T> & Decode<T>;
  *
  * Descriptors can be composed to form more complex typings.
  */
-declare class Descriptor<T, V = T> implements Codec<T>, Skip {
+declare class Descriptor<T, V = T> implements Codec<T>, Skip, CodecWithView<T, V> {
   /** A "lightweight" version of the object. */
   public readonly View: Descriptor<V>;
 
@@ -2686,6 +2690,10 @@ declare abstract class ObjectView<T> {
   toString() {
     return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
   }
+
+  [TEST_COMPARE_USING]() {
+    return this.materialize();
+  }
 }
 
 /**
@@ -3237,15 +3245,25 @@ declare namespace codec$1 {
       sizeHint: SizeHint;
     },
     chooser: (ctx: unknown | null) => Descriptor<T, V>,
-  ): Descriptor<T, V> =>
-    Descriptor.withView(
+  ): Descriptor<T, V> => {
+    const Self = chooser(null);
+    return Descriptor.withView(
       name,
       sizeHint,
       (e, x) => chooser(e.getContext()).encode(e, x),
       (d) => chooser(d.getContext()).decode(d),
       (s) => chooser(s.decoder.getContext()).skip(s),
-      chooser(null).View,
+      hasUniqueView(Self)
+        ? select(
+            {
+              name: Self.View.name,
+              sizeHint: Self.View.sizeHint,
+            },
+            (ctx) => chooser(ctx).View,
+          )
+        : Self.View,
     );
+  };
 
   /**
    * A descriptor for a more complex POJO.
@@ -3439,6 +3457,7 @@ 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;
@@ -3479,7 +3498,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_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_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 };
 }
 
 /**
@@ -6917,6 +6936,17 @@ 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;
@@ -6966,6 +6996,7 @@ 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;
@@ -6982,7 +7013,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_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_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 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 };
 }
 
@@ -9122,33 +9153,61 @@ declare function accumulationOutputComparator(a: AccumulationOutput, b: Accumula
 }
 
 /**
- * Assignment of particular work report to a core.
+ * `J`: The maximum sum of dependency items in a work-report.
  *
- * Used by "Assurances" and "Disputes" subsystem, denoted by `rho`
- * in state.
+ * 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/#/579bd12/135800135800
+ * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
  */
-declare class AvailabilityAssignment extends WithDebug {
-  static Codec = codec.Class(AvailabilityAssignment, {
-    workReport: WorkReport.Codec,
-    timeout: codec.u32.asOpaque<TimeSlot>(),
+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({ workReport, timeout }: CodecRecord<AvailabilityAssignment>) {
-    return new AvailabilityAssignment(workReport, timeout);
+  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
+    return new NotYetAccumulatedReport(report, dependencies);
   }
 
   private constructor(
-    /** Work report assigned to a core. */
-    public readonly workReport: WorkReport,
-    /** Time slot at which the report becomes obsolete. */
-    public readonly timeout: TimeSlot,
+    /**
+     * 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. */
@@ -9164,6 +9223,68 @@ declare const codecPerCore = <T, V>(val: Descriptor<T, V>): Descriptor<PerCore<T
     return codecKnownSizeArray(val, { fixedLength: context.coresCount });
   });
 
+/**
+ * Assignment of particular work report to a core.
+ *
+ * Used by "Assurances" and "Disputes" subsystem, denoted by `rho`
+ * in state.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/135800135800
+ */
+declare class AvailabilityAssignment extends WithDebug {
+  static Codec = codec.Class(AvailabilityAssignment, {
+    workReport: WorkReport.Codec,
+    timeout: codec.u32.asOpaque<TimeSlot>(),
+  });
+
+  static create({ workReport, timeout }: CodecRecord<AvailabilityAssignment>) {
+    return new AvailabilityAssignment(workReport, timeout);
+  }
+
+  private constructor(
+    /** Work report assigned to a core. */
+    public readonly workReport: WorkReport,
+    /** Time slot at which the report becomes obsolete. */
+    public readonly timeout: TimeSlot,
+  ) {
+    super();
+  }
+}
+
+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),
+);
+
 declare const sortedSetCodec = <T extends OpaqueHash>() =>
   readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert<ImmutableSortedSet<T>>(
     (input) => input.array,
@@ -9245,400 +9366,78 @@ declare function hashComparator<V extends OpaqueHash>(a: V, b: V) {
   return a.compare(b);
 }
 
-/**
- * `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;
+declare const SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
 
-/** `Q`: Size of the authorization queue. */
-declare const AUTHORIZATION_QUEUE_SIZE = Q;
-type AUTHORIZATION_QUEUE_SIZE = typeof AUTHORIZATION_QUEUE_SIZE;
+/** 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)[];
+}
 
-/** `O`: Maximal authorization pool size. */
-declare const MAX_AUTH_POOL_SIZE = O;
-type MAX_AUTH_POOL_SIZE = typeof MAX_AUTH_POOL_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;
+}
 
 /**
- * Ready (i.e. available and/or audited) but not-yet-accumulated work-reports.
+ * Merkle Mountain Range.
  *
- * https://graypaper.fluffylabs.dev/#/5f542d7/165300165400
+ * https://graypaper.fluffylabs.dev/#/5f542d7/3aa0023aa002?v=0.6.2
  */
-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,
-    }),
-  });
+declare class MerkleMountainRange<H extends OpaqueHash> {
+  /** Construct an empty MMR. */
+  static empty<H extends OpaqueHash>(hasher: MmrHasher<H>) {
+    return new MerkleMountainRange(hasher);
+  }
 
-  static create({ report, dependencies }: CodecRecord<NotYetAccumulatedReport>) {
-    return new NotYetAccumulatedReport(report, dependencies);
+  /** 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(
-    /**
-     * 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();
-  }
-}
+    private readonly hasher: MmrHasher<H>,
+    /** Store non-empty merkle tries (mountains) ordered by descending size. */
+    private readonly mountains: Mountain<H>[] = [],
+  ) {}
 
-/**
- * `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;
+  /**
+   * 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);
 
-declare const zeroSizeHint: SizeHint = {
-  bytes: 0,
-  isExact: true,
-};
+    for (;;) {
+      const last = this.mountains.pop();
+      if (last === undefined) {
+        this.mountains.push(newMountain);
+        return;
+      }
 
-/** 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);
-    },
-    (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;
-      }
+      if (last.size !== newMountain.size) {
+        this.mountains.push(last);
+        this.mountains.push(newMountain);
+        return;
+      }
 
       newMountain = last.mergeWith(this.hasher, newMountain);
     }
@@ -9763,6 +9562,11 @@ 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, {
@@ -9775,6 +9579,12 @@ declare class RecentBlocks extends WithDebug {
     }),
   });
 
+  static empty() {
+    return new RecentBlocks(asKnownSize([]), {
+      peaks: [],
+    });
+  }
+
   static create(a: CodecRecord<RecentBlocks>) {
     return new RecentBlocks(a.blocks, a.accumulationLog);
   }
@@ -9793,80 +9603,23 @@ declare class RecentBlocks extends WithDebug {
   ) {
     super();
   }
-}
-
-/**
- * Recent history of blocks.
- *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/0fc9010fc901?v=0.6.7
- */
-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);
-    },
-    (skip) => {
-      return RecentBlocks.Codec.skip(skip);
-    },
-  );
-
-  static create(recentBlocks: RecentBlocks) {
-    return new RecentBlocksHistory(recentBlocks);
-  }
-
-  static empty() {
-    return RecentBlocksHistory.create(
-      RecentBlocks.create({
-        blocks: asKnownSize([]),
-        accumulationLog: { peaks: [] },
-      }),
-    );
-  }
-
-  /**
-   * Returns the block's BEEFY super peak.
-   */
-  static accumulationResult(block: BlockState): KeccakHash {
-    return (block as BlockState).accumulationResult;
-  }
-
-  private constructor(private readonly current: RecentBlocks | null) {
-    super();
-  }
-
-  /** History of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
-  get blocks(): readonly BlockState[] {
-    if (this.current !== null) {
-      return this.current.blocks;
-    }
+}
 
-    throw new Error("RecentBlocksHistory is in invalid state");
-  }
+type RecentBlocksView = DescribedBy<typeof RecentBlocks.Codec.View>;
 
-  asCurrent() {
-    if (this.current === null) {
-      throw new Error("Cannot access current RecentBlocks format");
-    }
-    return this.current;
-  }
+type RecentlyAccumulated = PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
 
-  updateBlocks(blocks: BlockState[]): RecentBlocksHistory {
-    if (this.current !== null) {
-      return RecentBlocksHistory.create(
-        RecentBlocks.create({
-          ...this.current,
-          blocks: asOpaqueType(blocks as BlockState[]),
-        }),
-      );
-    }
+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),
+  ),
+);
 
-    throw new Error("RecentBlocksHistory is in invalid state. Cannot be updated!");
-  }
-}
+type RecentlyAccumulatedView = DescribedBy<typeof recentlyAccumulatedCodec.View>;
 
 /**
  * Fixed size of validator metadata.
@@ -9907,6 +9660,10 @@ declare class ValidatorData extends WithDebug {
   }
 }
 
+type ValidatorDataView = DescribedBy<typeof ValidatorData.Codec.View>;
+
+declare const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
+
 declare enum SafroleSealingKeysKind {
   Tickets = 0,
   Keys = 1,
@@ -9970,44 +9727,317 @@ declare class SafroleSealingKeysData extends WithDebug {
     );
   });
 
-  static keys(keys: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
+  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;
+/**
+ * `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;
+
+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);
+    },
+    (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();
+  }
+}
+
+type ServiceAccountInfoView = DescribedBy<typeof ServiceAccountInfo.Codec.View>;
+
+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;
   }
+}
 
-  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
-    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
+/** 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(
-    readonly kind: SafroleSealingKeysKind,
-    readonly keys?: PerEpochBlock<BandersnatchKey>,
-    readonly tickets?: PerEpochBlock<Ticket>,
-  ) {
-    super();
-  }
+    /** Service id that auto-accumulates. */
+    readonly service: ServiceId,
+    /** Gas limit for auto-accumulation. */
+    readonly gasLimit: ServiceGas,
+  ) {}
 }
 
-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),
+/**
+ * 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({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
-    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
+  static create(a: CodecRecord<PrivilegedServices>) {
+    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
   }
 
   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">,
+    /**
+     * `χ_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[],
   ) {}
 }
 
@@ -10289,6 +10319,8 @@ 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
@@ -10340,7 +10372,7 @@ type State = {
   /**
    * `γₖ gamma_k`: The keys for the validators of the next epoch, equivalent to those keys which constitute γ_z .
    */
-  readonly nextValidatorData: SafroleData["nextValidatorData"];
+  readonly nextValidatorData: PerValidator<ValidatorData>;
 
   /**
    * `κ kappa`: Validators, who are the set of economic actors uniquely
@@ -10386,7 +10418,7 @@ type State = {
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
+  readonly authPools: PerCore<AuthorizationPool>;
 
   /**
    * `φ phi`: A queue of authorizers for each core used to fill up the pool.
@@ -10395,14 +10427,14 @@ type State = {
    *
    * https://graypaper-reader.netlify.app/#/6e1c0cd/102400102400
    */
-  readonly authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
+  readonly authQueues: PerCore<AuthorizationQueue>;
 
   /**
    * `β beta`: State of the blocks from recent history.
    *
    * https://graypaper.fluffylabs.dev/#/579bd12/0fb7010fb701
    */
-  readonly recentBlocks: RecentBlocksHistory;
+  readonly recentBlocks: RecentBlocks;
 
   /**
    * `π pi`: Previous and current statistics of each validator,
@@ -10419,7 +10451,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/165300165500
    */
-  readonly accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
+  readonly accumulationQueue: AccumulationQueue;
 
   /**
    * `ξ xi`: In order to know which work-packages have been
@@ -10429,7 +10461,7 @@ type State = {
    *
    * https://graypaper.fluffylabs.dev/#/5f542d7/161a00161d00
    */
-  readonly recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
+  readonly recentlyAccumulated: RecentlyAccumulated;
 
   /*
    * `γₐ gamma_a`: The ticket accumulator - a series of highest-scoring ticket identifiers to be
@@ -10502,6 +10534,113 @@ 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,
@@ -10824,10 +10963,10 @@ declare class InMemoryService extends WithDebug implements Service {
 /**
  * A special version of state, stored fully in-memory.
  */
-declare class InMemoryState extends WithDebug implements State, EnumerableState {
+declare class InMemoryState extends WithDebug implements State, WithStateView, EnumerableState {
   /** Create a new `InMemoryState` by providing all required fields. */
-  static create(state: InMemoryStateFields) {
-    return new InMemoryState(state);
+  static new(chainSpec: ChainSpec, state: InMemoryStateFields) {
+    return new InMemoryState(chainSpec, state);
   }
 
   /**
@@ -10845,7 +10984,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
   /**
    * Create a new `InMemoryState` from some other state object.
    */
-  static copyFrom(other: State, servicesData: Map<ServiceId, ServiceEntries>) {
+  static copyFrom(chainSpec: ChainSpec, other: State, servicesData: Map<ServiceId, ServiceEntries>) {
     const services = new Map<ServiceId, InMemoryService>();
     for (const [id, entries] of servicesData.entries()) {
       const service = other.getService(id);
@@ -10856,7 +10995,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
       services.set(id, inMemService);
     }
 
-    return InMemoryState.create({
+    return InMemoryState.new(chainSpec, {
       availabilityAssignment: other.availabilityAssignment,
       accumulationQueue: other.accumulationQueue,
       designatedValidatorData: other.designatedValidatorData,
@@ -11051,12 +11190,12 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
   disputesRecords: DisputesRecords;
   timeslot: TimeSlot;
   entropy: FixedSizeArray<EntropyHash, ENTROPY_ENTRIES>;
-  authPools: PerCore<KnownSizeArray<AuthorizerHash, `At most ${typeof MAX_AUTH_POOL_SIZE}`>>;
-  authQueues: PerCore<FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>>;
-  recentBlocks: RecentBlocksHistory;
+  authPools: PerCore<AuthorizationPool>;
+  authQueues: PerCore<AuthorizationQueue>;
+  recentBlocks: RecentBlocks;
   statistics: StatisticsData;
-  accumulationQueue: PerEpochBlock<readonly NotYetAccumulatedReport[]>;
-  recentlyAccumulated: PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
+  accumulationQueue: AccumulationQueue;
+  recentlyAccumulated: RecentlyAccumulated;
   ticketsAccumulator: KnownSizeArray<Ticket, "0...EpochLength">;
   sealingKeySeries: SafroleSealingKeys;
   epochRoot: BandersnatchRingRoot;
@@ -11072,7 +11211,10 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
     return this.services.get(id) ?? null;
   }
 
-  private constructor(s: InMemoryStateFields) {
+  protected constructor(
+    private readonly chainSpec: ChainSpec,
+    s: InMemoryStateFields,
+  ) {
     super();
     this.availabilityAssignment = s.availabilityAssignment;
     this.designatedValidatorData = s.designatedValidatorData;
@@ -11096,11 +11238,15 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
     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({
+    return new InMemoryState(spec, {
       availabilityAssignment: tryAsPerCore(
         Array.from({ length: spec.coresCount }, () => null),
         spec,
@@ -11167,7 +11313,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
         ),
         spec,
       ),
-      recentBlocks: RecentBlocksHistory.empty(),
+      recentBlocks: RecentBlocks.empty(),
       statistics: StatisticsData.create({
         current: tryAsPerValidator(
           Array.from({ length: spec.validatorsCount }, () => ValidatorStatistics.empty()),
@@ -11253,12 +11399,18 @@ 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;
@@ -11280,8 +11432,11 @@ 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;
@@ -11289,10 +11444,12 @@ 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_RecentBlocksHistory = RecentBlocksHistory;
-declare const index$e_RecentBlocksHistory: typeof RecentBlocksHistory;
+type index$e_RecentBlocksView = RecentBlocksView;
+type index$e_RecentlyAccumulated = RecentlyAccumulated;
+type index$e_RecentlyAccumulatedView = RecentlyAccumulatedView;
 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;
@@ -11301,14 +11458,17 @@ 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;
@@ -11329,9 +11489,15 @@ 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;
@@ -11340,16 +11506,18 @@ 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_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 };
+  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 };
 }
 
 type StateKey = Opaque<OpaqueHash, "stateKey">;
@@ -11490,33 +11658,25 @@ declare function legacyServiceNested(serviceId: ServiceId, hash: OpaqueHash): St
   return key.asOpaque();
 }
 
-type StateCodec<T> = {
+type StateCodec<T, V = T> = {
   key: StateKey;
-  Codec: Descriptor<T>;
+  Codec: Descriptor<T, V>;
   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"]> = {
+  export const authPools: StateCodec<State["authPools"], ReturnType<StateView["authPoolsView"]>> = {
     key: stateKeys.index(StateKeyIdx.Alpha),
-    Codec: codecPerCore(
-      codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), {
-        minLength: 0,
-        maxLength: MAX_AUTH_POOL_SIZE,
-        typicalLength: MAX_AUTH_POOL_SIZE,
-      }),
-    ),
+    Codec: authPoolsCodec,
     extract: (s) => s.authPools,
   };
 
   /** C(2): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b31013b3101?v=0.6.7 */
-  export const authQueues: StateCodec<State["authQueues"]> = {
+  export const authQueues: StateCodec<State["authQueues"], ReturnType<StateView["authQueuesView"]>> = {
     key: stateKeys.index(StateKeyIdx.Phi),
-    Codec: codecPerCore(
-      codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque<AuthorizerHash>(), AUTHORIZATION_QUEUE_SIZE),
-    ),
+    Codec: authQueuesCodec,
     extract: (s) => s.authQueues,
   };
 
@@ -11524,14 +11684,14 @@ declare namespace serialize {
    * C(3): Recent blocks with compatibility
    *  https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e013b3e01?v=0.6.7
    */
-  export const recentBlocks: StateCodec<State["recentBlocks"]> = {
+  export const recentBlocks: StateCodec<RecentBlocks, RecentBlocksView> = {
     key: stateKeys.index(StateKeyIdx.Beta),
-    Codec: RecentBlocksHistory.Codec,
+    Codec: RecentBlocks.Codec,
     extract: (s) => s.recentBlocks,
   };
 
   /** C(4): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b63013b6301?v=0.6.7 */
-  export const safrole: StateCodec<SafroleData> = {
+  export const safrole: StateCodec<SafroleData, SafroleDataView> = {
     key: stateKeys.index(StateKeyIdx.Gamma),
     Codec: SafroleData.Codec,
     extract: (s) =>
@@ -11544,7 +11704,7 @@ declare namespace serialize {
   };
 
   /** C(5): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bba013bba01?v=0.6.7 */
-  export const disputesRecords: StateCodec<State["disputesRecords"]> = {
+  export const disputesRecords: StateCodec<DisputesRecords> = {
     key: stateKeys.index(StateKeyIdx.Psi),
     Codec: DisputesRecords.Codec,
     extract: (s) => s.disputesRecords,
@@ -11558,30 +11718,42 @@ declare namespace serialize {
   };
 
   /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
-  export const designatedValidators: StateCodec<State["designatedValidatorData"]> = {
+  export const designatedValidators: StateCodec<
+    State["designatedValidatorData"],
+    ReturnType<StateView["designatedValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Iota),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.designatedValidatorData,
   };
 
   /** C(8): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b0d023b0d02?v=0.6.7 */
-  export const currentValidators: StateCodec<State["currentValidatorData"]> = {
+  export const currentValidators: StateCodec<
+    State["currentValidatorData"],
+    ReturnType<StateView["currentValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Kappa),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.currentValidatorData,
   };
 
   /** C(9): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b1a023b1a02?v=0.6.7 */
-  export const previousValidators: StateCodec<State["previousValidatorData"]> = {
+  export const previousValidators: StateCodec<
+    State["previousValidatorData"],
+    ReturnType<StateView["previousValidatorDataView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Lambda),
-    Codec: codecPerValidator(ValidatorData.Codec),
+    Codec: validatorsDataCodec,
     extract: (s) => s.previousValidatorData,
   };
 
   /** C(10): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b27023b2702?v=0.6.7 */
-  export const availabilityAssignment: StateCodec<State["availabilityAssignment"]> = {
+  export const availabilityAssignment: StateCodec<
+    State["availabilityAssignment"],
+    ReturnType<StateView["availabilityAssignmentView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Rho),
-    Codec: codecPerCore(codec.optional(AvailabilityAssignment.Codec)),
+    Codec: availabilityAssignmentsCodec,
     extract: (s) => s.availabilityAssignment,
   };
 
@@ -11600,28 +11772,29 @@ declare namespace serialize {
   };
 
   /** C(13): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b5e023b5e02?v=0.6.7 */
-  export const statistics: StateCodec<State["statistics"]> = {
+  export const statistics: StateCodec<StatisticsData, StatisticsDataView> = {
     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"]> = {
+  export const accumulationQueue: StateCodec<
+    State["accumulationQueue"],
+    ReturnType<StateView["accumulationQueueView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Omega),
-    Codec: codecPerEpochBlock(readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec))),
+    Codec: accumulationQueueCodec,
     extract: (s) => s.accumulationQueue,
   };
 
   /** C(15): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b96023b9602?v=0.6.7 */
-  export const recentlyAccumulated: StateCodec<State["recentlyAccumulated"]> = {
+  export const recentlyAccumulated: StateCodec<
+    State["recentlyAccumulated"],
+    ReturnType<StateView["recentlyAccumulatedView"]>
+  > = {
     key: stateKeys.index(StateKeyIdx.Xi),
-    Codec: codecPerEpochBlock(
-      codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque<WorkPackageHash>()).convert(
-        (x) => Array.from(x),
-        (x) => HashSet.from(x),
-      ),
-    ),
+    Codec: recentlyAccumulatedCodec,
     extract: (s) => s.recentlyAccumulated,
   };
 
@@ -11677,6 +11850,107 @@ 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. */
@@ -12055,16 +12329,6 @@ 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.
  *
@@ -12074,7 +12338,7 @@ interface SerializedStateBackend {
  * in the backend layer, so it MAY fail during runtime.
  */
 declare class SerializedState<T extends SerializedStateBackend = SerializedStateBackend>
-  implements State, EnumerableState
+  implements State, WithStateView, EnumerableState
 {
   /** Create a state-like object from collection of serialized entries. */
   static fromStateEntries(spec: ChainSpec, blake2b: Blake2b, state: StateEntries, recentServices: ServiceId[] = []) {
@@ -12091,12 +12355,15 @@ 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 _recentServiceIds: ServiceId[],
+    private readonly recentlyUsedServices: ServiceId[],
   ) {}
 
   /** Comparing the serialized states, just means comparing their backends. */
@@ -12104,14 +12371,21 @@ 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._recentServiceIds;
+    return this.recentlyUsedServices;
   }
 
   getService(id: ServiceId): SerializedService | null {
@@ -12120,27 +12394,33 @@ declare class SerializedState<T extends SerializedStateBackend = SerializedState
       return null;
     }
 
-    if (!this._recentServiceIds.includes(id)) {
-      this._recentServiceIds.push(id);
+    if (!this.recentlyUsedServices.includes(id)) {
+      this.recentlyUsedServices.push(id);
     }
 
     return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
   }
 
-  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}`);
+  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}`);
     }
-    return Decoder.decodeObject(Codec, bytes, this.spec);
+    return data;
   }
 
   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;
     }
-    return Decoder.decodeObject(Codec, bytes, this.spec);
+    const data = Decoder.decodeObject(Codec, bytes, this.spec);
+    this.dataCache.set(key, data);
+    return data;
   }
 
   get availabilityAssignment(): State["availabilityAssignment"] {
@@ -12313,12 +12593,15 @@ 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_StateCodec<T> = StateCodec<T>;
+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_StateEntries = StateEntries;
 declare const index$d_StateEntries: typeof StateEntries;
 type index$d_StateEntryUpdate = StateEntryUpdate;
@@ -12346,8 +12629,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_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 };
+  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 };
 }
 
 /** Error during `LeafDb` creation. */
@@ -12542,7 +12825,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, state, this.spec);
+    const encoded = Encoder.encodeObject(inMemoryStateCodec(this.spec), state, this.spec);
     this.db.set(headerHash, encoded);
     return Result.ok(OK);
   }
@@ -12553,7 +12836,7 @@ declare class InMemoryStates implements StatesDb<InMemoryState> {
       return null;
     }
 
-    return Decoder.decodeObject(inMemoryStateCodec, encodedState, this.spec);
+    return Decoder.decodeObject(inMemoryStateCodec(this.spec), encodedState, this.spec);
   }
 }
 
@@ -13815,8 +14098,8 @@ interface PartialState {
   /** Update authorization queue for given core and authorize a service for this core. */
   updateAuthorizationQueue(
     coreIndex: CoreIndex,
-    authQueue: FixedSizeArray<Blake2bHash, AUTHORIZATION_QUEUE_SIZE>,
-    assigners: ServiceId | null,
+    authQueue: AuthorizationQueue,
+    assigner: ServiceId | null,
   ): Result$2<OK, UpdatePrivilegesError>;
 
   /**
@@ -19281,7 +19564,7 @@ type JsonRecentBlockState = {
   reported: WorkPackageInfo[];
 };
 
-declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocksHistory>(
+declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, RecentBlocks>(
   {
     history: json.array(recentBlockStateFromJson),
     mmr: {
@@ -19289,12 +19572,10 @@ declare const recentBlocksHistoryFromJson = json.object<JsonRecentBlocks, Recent
     },
   },
   ({ history, mmr }) => {
-    return RecentBlocksHistory.create(
-      RecentBlocks.create({
-        blocks: history,
-        accumulationLog: mmr,
-      }),
-    );
+    return RecentBlocks.create({
+      blocks: history,
+      accumulationLog: mmr,
+    });
   },
 );
 
@@ -19606,7 +19887,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.create({
+      return InMemoryState.new(spec, {
         authPools: tryAsPerCore(
           alpha.map((perCore) => {
             if (perCore.length > MAX_AUTH_POOL_SIZE) {
@@ -19625,7 +19906,7 @@ declare const fullStateDumpFromJson = (spec: ChainSpec) =>
           }),
           spec,
         ),
-        recentBlocks: beta ?? RecentBlocksHistory.empty(),
+        recentBlocks: beta ?? RecentBlocks.empty(),
         nextValidatorData: gamma.gamma_k,
         epochRoot: gamma.gamma_z,
         sealingKeySeries: TicketsOrKeys.toSafroleSealingKeys(gamma.gamma_s, spec),
@@ -19730,23 +20011,25 @@ declare class TransitionHasher implements MmrHasher<KeccakHash> {
    */
   extrinsic(extrinsicView: ExtrinsicView): WithHashAndBytes<ExtrinsicHash, ExtrinsicView> {
     // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
-    const guarantees = extrinsicView.guarantees
+    const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
+    const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
+    const guaranteesBlobs = extrinsicView.guarantees
       .view()
       .map((g) => g.view())
-      .map((guarantee) => {
-        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);
+      .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],
+      );
 
     const et = this.blake2b.hashBytes(extrinsicView.tickets.encoded()).asOpaque<ExtrinsicHash>();
     const ep = this.blake2b.hashBytes(extrinsicView.preimages.encoded()).asOpaque<ExtrinsicHash>();
-    const eg = this.blake2b.hashBytes(guaranteeBlob).asOpaque<ExtrinsicHash>();
+    const eg = this.blake2b.hashBlobs(guaranteesBlobs).asOpaque<ExtrinsicHash>();
     const ea = this.blake2b.hashBytes(extrinsicView.assurances.encoded()).asOpaque<ExtrinsicHash>();
     const ed = this.blake2b.hashBytes(extrinsicView.disputes.encoded()).asOpaque<ExtrinsicHash>();