@typeberry/lib 0.2.0-b6e3410 → 0.2.0-c3df163

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,769 +9366,678 @@ 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) => {},
-  );
+      if (last.size !== newMountain.size) {
+        this.mountains.push(last);
+        this.mountains.push(newMountain);
+        return;
+      }
 
-/** 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,
-    );
+      newMountain = last.mergeWith(this.hasher, newMountain);
+    }
   }
 
   /**
-   * `a_t = max(0, BS + BI * a_i + BL * a_o - a_f)`
-   * https://graypaper.fluffylabs.dev/#/7e6ff6a/119e01119e01?v=0.6.7
+   * Root of the entire structure.
+   *
+   * https://graypaper.fluffylabs.dev/#/5f542d7/3b20013b2001?v=0.6.2
    */
-  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);
+  getSuperPeakHash(): H {
+    if (this.mountains.length === 0) {
+      return Bytes.zero(HASH_SIZE).asOpaque();
     }
-
-    if (storageCost >= 2n ** 64n) {
-      return tryAsU64(2n ** 64n - 1n);
+    const revMountains = this.mountains.slice().reverse();
+    const length = revMountains.length;
+    let lastHash = revMountains[0].peak;
+    for (let i = 1; i < length; i++) {
+      const mountain = revMountains[i];
+      lastHash = this.hasher.hashConcatPrepend(SUPER_PEAK_STRING, lastHash, mountain.peak);
     }
+    return lastHash;
+  }
 
-    return tryAsU64(storageCost);
+  /** Get current peaks. */
+  getPeaks(): MmrPeaks<H> {
+    const peaks: (H | null)[] = [];
+    const mountains = this.mountains;
+
+    // always 2**index
+    let currentSize = 1;
+    let currentIdx = mountains.length - 1;
+    while (currentIdx >= 0) {
+      const currentItem = mountains[currentIdx];
+      if (currentItem.size >= currentSize && currentItem.size < 2 * currentSize) {
+        peaks.push(currentItem.peak);
+        currentIdx -= 1;
+      } else {
+        peaks.push(null);
+      }
+      // move to the next index.
+      currentSize = currentSize << 1;
+    }
+    return { peaks };
   }
+}
 
+/** An internal helper structure to represent a merkle trie for MMR. */
+declare class Mountain<H extends OpaqueHash> {
   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();
+    public readonly peak: H,
+    public readonly size: number,
+  ) {}
+
+  static fromPeak<H extends OpaqueHash>(peak: H, size: number) {
+    return new Mountain(peak, size);
+  }
+
+  static fromChildren<H extends OpaqueHash>(hasher: MmrHasher<H>, children: [Mountain<H>, Mountain<H>]) {
+    const [left, right] = children;
+    const peak = hasher.hashConcat(left.peak, right.peak);
+    const size = left.size + right.size;
+    return new Mountain(peak, size);
+  }
+  /** Merge with another montain of the same size. */
+  mergeWith(hasher: MmrHasher<H>, other: Mountain<H>): Mountain<H> {
+    return Mountain.fromChildren(hasher, [this, other]);
+  }
+
+  toString() {
+    return `${this.size} @ ${this.peak}`;
   }
 }
 
-declare class PreimageItem extends WithDebug {
-  static Codec = codec.Class(PreimageItem, {
-    hash: codec.bytes(HASH_SIZE).asOpaque<PreimageHash>(),
-    blob: codec.blob,
+type index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
+declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
+type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
+type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
+type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
+declare const index$f_Mountain: typeof Mountain;
+declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
+declare namespace index$f {
+  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
+  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
+}
+
+/**
+ * `H = 8`: The size of recent history, in blocks.
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ */
+declare const MAX_RECENT_HISTORY = 8;
+type MAX_RECENT_HISTORY = typeof MAX_RECENT_HISTORY;
+
+/** Array of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
+type BlocksState = KnownSizeArray<BlockState, `0..${typeof MAX_RECENT_HISTORY}`>;
+
+/** Recent history of a single block. */
+declare class BlockState extends WithDebug {
+  static Codec = codec.Class(BlockState, {
+    headerHash: codec.bytes(HASH_SIZE).asOpaque<HeaderHash>(),
+    accumulationResult: codec.bytes(HASH_SIZE),
+    postStateRoot: codec.bytes(HASH_SIZE).asOpaque<StateRootHash>(),
+    reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
   });
 
-  static create({ hash, blob }: CodecRecord<PreimageItem>) {
-    return new PreimageItem(hash, blob);
+  static create({ headerHash, accumulationResult, postStateRoot, reported }: CodecRecord<BlockState>) {
+    return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
   }
 
   private constructor(
-    readonly hash: PreimageHash,
-    readonly blob: BytesBlob,
+    /** Header hash. */
+    public readonly headerHash: HeaderHash,
+    /** Merkle mountain belt of accumulation result. */
+    public readonly accumulationResult: KeccakHash,
+    /** Posterior state root filled in with a 1-block delay. */
+    public postStateRoot: StateRootHash,
+    /** Reported work packages (no more than number of cores). */
+    public readonly reported: HashDictionary<WorkPackageHash, WorkPackageInfo>,
   ) {
     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,
+/**
+ * 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, {
+      minLength: 0,
+      maxLength: MAX_RECENT_HISTORY,
+      typicalLength: MAX_RECENT_HISTORY,
+    }),
+    accumulationLog: codec.object({
+      peaks: readonlyArray(codec.sequenceVarLen(codec.optional(codec.bytes(HASH_SIZE)))),
+    }),
   });
 
-  static create({ key, value }: CodecRecord<StorageItem>) {
-    return new StorageItem(key, value);
+  static empty() {
+    return new RecentBlocks(asKnownSize([]), {
+      peaks: [],
+    });
+  }
+
+  static create(a: CodecRecord<RecentBlocks>) {
+    return new RecentBlocks(a.blocks, a.accumulationLog);
   }
 
   private constructor(
-    readonly key: StorageKey,
-    readonly value: BytesBlob,
+    /**
+     * Most recent blocks.
+     * 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();
   }
 }
 
-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;
-}
+type RecentBlocksView = DescribedBy<typeof RecentBlocks.Codec.View>;
 
-/** 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,
-  ) {}
+type RecentlyAccumulated = PerEpochBlock<ImmutableHashSet<WorkPackageHash>>;
 
-  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>(),
-  });
+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),
+  ),
+);
 
-  static create({ service, gasLimit }: CodecRecord<AutoAccumulate>) {
-    return new AutoAccumulate(service, gasLimit);
-  }
+type RecentlyAccumulatedView = DescribedBy<typeof recentlyAccumulatedCodec.View>;
 
-  private constructor(
-    /** Service id that auto-accumulates. */
-    readonly service: ServiceId,
-    /** Gas limit for auto-accumulation. */
-    readonly gasLimit: ServiceGas,
-  ) {}
-}
+/**
+ * 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;
 
 /**
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
+ * Details about validators' identity.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/0d4b010d4c01
  */
-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 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(a: CodecRecord<PrivilegedServices>) {
-    return new PrivilegedServices(a.manager, a.delegator, a.registrar, a.assigners, a.autoAccumulateServices);
+  static create({ ed25519, bandersnatch, bls, metadata }: CodecRecord<ValidatorData>) {
+    return new ValidatorData(bandersnatch, ed25519, bls, metadata);
   }
 
   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[],
-  ) {}
+    /** 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 SUPER_PEAK_STRING = BytesBlob.blobFromString("peak");
+type ValidatorDataView = DescribedBy<typeof ValidatorData.Codec.View>;
 
-/** 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)[];
-}
+declare const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
 
-/** 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;
+declare enum SafroleSealingKeysKind {
+  Tickets = 0,
+  Keys = 1,
 }
 
-/**
- * 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);
-  }
+type SafroleSealingKeys =
+  | {
+      kind: SafroleSealingKeysKind.Keys;
+      keys: PerEpochBlock<BandersnatchKey>;
+    }
+  | {
+      kind: SafroleSealingKeysKind.Tickets;
+      tickets: PerEpochBlock<Ticket>;
+    };
 
-  /** 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(),
-    );
-  }
+declare const codecBandersnatchKey = codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque<BandersnatchKey>();
 
-  private constructor(
-    private readonly hasher: MmrHasher<H>,
-    /** Store non-empty merkle tries (mountains) ordered by descending size. */
-    private readonly mountains: Mountain<H>[] = [],
-  ) {}
+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));
+        }
 
-  /**
-   * 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);
+        if (kind === SafroleSealingKeysKind.Tickets) {
+          const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+          return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
+        }
 
-    for (;;) {
-      const last = this.mountains.pop();
-      if (last === undefined) {
-        this.mountains.push(newMountain);
-        return;
-      }
+        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;
+        }
 
-      if (last.size !== newMountain.size) {
-        this.mountains.push(last);
-        this.mountains.push(newMountain);
-        return;
-      }
+        throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+      },
+    );
+  });
 
-      newMountain = last.mergeWith(this.hasher, newMountain);
-    }
+  static keys(keys: PerEpochBlock<BandersnatchKey>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Keys, keys, undefined) as SafroleSealingKeys;
   }
 
-  /**
-   * 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++) {
-      const mountain = revMountains[i];
-      lastHash = this.hasher.hashConcatPrepend(SUPER_PEAK_STRING, lastHash, mountain.peak);
-    }
-    return lastHash;
+  static tickets(tickets: PerEpochBlock<Ticket>): SafroleSealingKeys {
+    return new SafroleSealingKeysData(SafroleSealingKeysKind.Tickets, undefined, tickets) as SafroleSealingKeys;
   }
 
-  /** Get current peaks. */
-  getPeaks(): MmrPeaks<H> {
-    const peaks: (H | null)[] = [];
-    const mountains = this.mountains;
-
-    // always 2**index
-    let currentSize = 1;
-    let currentIdx = mountains.length - 1;
-    while (currentIdx >= 0) {
-      const currentItem = mountains[currentIdx];
-      if (currentItem.size >= currentSize && currentItem.size < 2 * currentSize) {
-        peaks.push(currentItem.peak);
-        currentIdx -= 1;
-      } else {
-        peaks.push(null);
-      }
-      // move to the next index.
-      currentSize = currentSize << 1;
-    }
-    return { peaks };
+  private constructor(
+    readonly kind: SafroleSealingKeysKind,
+    readonly keys?: PerEpochBlock<BandersnatchKey>,
+    readonly tickets?: PerEpochBlock<Ticket>,
+  ) {
+    super();
   }
 }
 
-/** An internal helper structure to represent a merkle trie for MMR. */
-declare class Mountain<H extends OpaqueHash> {
-  private constructor(
-    public readonly peak: H,
-    public readonly size: number,
-  ) {}
-
-  static fromPeak<H extends OpaqueHash>(peak: H, size: number) {
-    return new Mountain(peak, size);
-  }
+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 fromChildren<H extends OpaqueHash>(hasher: MmrHasher<H>, children: [Mountain<H>, Mountain<H>]) {
-    const [left, right] = children;
-    const peak = hasher.hashConcat(left.peak, right.peak);
-    const size = left.size + right.size;
-    return new Mountain(peak, size);
-  }
-  /** Merge with another montain of the same size. */
-  mergeWith(hasher: MmrHasher<H>, other: Mountain<H>): Mountain<H> {
-    return Mountain.fromChildren(hasher, [this, other]);
+  static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>) {
+    return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
   }
 
-  toString() {
-    return `${this.size} @ ${this.peak}`;
-  }
+  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 index$f_MerkleMountainRange<H extends OpaqueHash> = MerkleMountainRange<H>;
-declare const index$f_MerkleMountainRange: typeof MerkleMountainRange;
-type index$f_MmrHasher<H extends OpaqueHash> = MmrHasher<H>;
-type index$f_MmrPeaks<H extends OpaqueHash> = MmrPeaks<H>;
-type index$f_Mountain<H extends OpaqueHash> = Mountain<H>;
-declare const index$f_Mountain: typeof Mountain;
-declare const index$f_SUPER_PEAK_STRING: typeof SUPER_PEAK_STRING;
-declare namespace index$f {
-  export { index$f_MerkleMountainRange as MerkleMountainRange, index$f_Mountain as Mountain, index$f_SUPER_PEAK_STRING as SUPER_PEAK_STRING };
-  export type { index$f_MmrHasher as MmrHasher, index$f_MmrPeaks as MmrPeaks };
-}
+type SafroleDataView = DescribedBy<typeof SafroleData.Codec.View>;
 
 /**
- * `H = 8`: The size of recent history, in blocks.
+ * `B_S`: The basic minimum balance which all services require.
  *
- * https://graypaper.fluffylabs.dev/#/579bd12/416300416500
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/445800445800?v=0.6.7
  */
-declare const MAX_RECENT_HISTORY = 8;
-type MAX_RECENT_HISTORY = typeof MAX_RECENT_HISTORY;
+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;
 
-/** Array of recent blocks with maximum size of `MAX_RECENT_HISTORY` */
-type BlocksState = KnownSizeArray<BlockState, `0..${typeof MAX_RECENT_HISTORY}`>;
+declare const zeroSizeHint: SizeHint = {
+  bytes: 0,
+  isExact: true,
+};
 
-/** Recent history of a single block. */
-declare class BlockState extends WithDebug {
-  static Codec = codec.Class(BlockState, {
-    headerHash: codec.bytes(HASH_SIZE).asOpaque<HeaderHash>(),
-    accumulationResult: codec.bytes(HASH_SIZE),
-    postStateRoot: codec.bytes(HASH_SIZE).asOpaque<StateRootHash>(),
-    reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
+/** 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({ headerHash, accumulationResult, postStateRoot, reported }: CodecRecord<BlockState>) {
-    return new BlockState(headerHash, accumulationResult, postStateRoot, reported);
+  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(
-    /** Header hash. */
-    public readonly headerHash: HeaderHash,
-    /** Merkle mountain belt of accumulation result. */
-    public readonly accumulationResult: KeccakHash,
-    /** Posterior state root filled in with a 1-block delay. */
-    public postStateRoot: StateRootHash,
-    /** Reported work packages (no more than number of cores). */
-    public readonly reported: HashDictionary<WorkPackageHash, WorkPackageInfo>,
+    /** `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 RecentBlocks extends WithDebug {
-  static Codec = codec.Class(RecentBlocks, {
-    blocks: codecKnownSizeArray(BlockState.Codec, {
-      minLength: 0,
-      maxLength: MAX_RECENT_HISTORY,
-      typicalLength: MAX_RECENT_HISTORY,
-    }),
-    accumulationLog: codec.object({
-      peaks: readonlyArray(codec.sequenceVarLen(codec.optional(codec.bytes(HASH_SIZE)))),
-    }),
+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(a: CodecRecord<RecentBlocks>) {
-    return new RecentBlocks(a.blocks, a.accumulationLog);
+  static create({ hash, blob }: CodecRecord<PreimageItem>) {
+    return new PreimageItem(hash, blob);
   }
 
   private constructor(
-    /**
-     * Most recent blocks.
-     * 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>,
+    readonly hash: PreimageHash,
+    readonly blob: BytesBlob,
   ) {
     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);
-  }
+type StorageKey = Opaque<BytesBlob, "storage key">;
 
-  static empty() {
-    return RecentBlocksHistory.create(
-      RecentBlocks.create({
-        blocks: asKnownSize([]),
-        accumulationLog: { peaks: [] },
-      }),
-    );
-  }
+declare class StorageItem extends WithDebug {
+  static Codec = codec.Class(StorageItem, {
+    key: codec.blob.convert(
+      (i) => i,
+      (o) => asOpaqueType(o),
+    ),
+    value: codec.blob,
+  });
 
-  /**
-   * Returns the block's BEEFY super peak.
-   */
-  static accumulationResult(block: BlockState): KeccakHash {
-    return (block as BlockState).accumulationResult;
+  static create({ key, value }: CodecRecord<StorageItem>) {
+    return new StorageItem(key, value);
   }
 
-  private constructor(private readonly current: RecentBlocks | null) {
+  private constructor(
+    readonly key: StorageKey,
+    readonly value: BytesBlob,
+  ) {
     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");
-  }
-
-  asCurrent() {
-    if (this.current === null) {
-      throw new Error("Cannot access current RecentBlocks format");
-    }
-    return this.current;
-  }
-
-  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!");
+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;
 }
 
-/**
- * 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);
-  }
+/** 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,
+  ) {}
 
-  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();
+  static isRequested(item: LookupHistoryItem | LookupHistorySlots): boolean {
+    if ("slots" in item) {
+      return item.slots.length === 0;
+    }
+    return item.length === 0;
   }
 }
 
-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}`);
-      },
-    );
+/** 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 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;
+  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,61 +10534,168 @@ interface Service {
   getLookupHistory(hash: PreimageHash, len: U32): LookupHistorySlots | null;
 }
 
-declare enum UpdatePreimageKind {
-  /** Insert new preimage and optionally update it's lookup history. */
-  Provide = 0,
-  /** Remove a preimage and it's lookup history. */
-  Remove = 1,
-  /** update or add lookup history for preimage hash/len to given value. */
-  UpdateOrAdd = 2,
-}
+/** Additional marker interface, when state view is supported/required. */
+type WithStateView<V = StateView> = {
+  /** Get view of the state. */
+  view(): V;
+};
+
 /**
- * A preimage update.
+ * A non-decoding version of the `State`.
  *
- * Can be one of the following cases:
- * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
- * 2. Remove (expunge) a preimage and it's lookup history.
- * 3. Update `LookupHistory` with given value.
+ * 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
  */
-declare class UpdatePreimage {
-  private constructor(
-    public readonly serviceId: ServiceId,
-    public readonly action:
-      | {
-          kind: UpdatePreimageKind.Provide;
-          preimage: PreimageItem;
-          // optionally set lookup history of that preimage to "available"
-          slot: TimeSlot | null;
-        }
-      | {
-          kind: UpdatePreimageKind.Remove;
-          hash: PreimageHash;
-          length: U32;
-        }
-      | {
-          kind: UpdatePreimageKind.UpdateOrAdd;
-          item: LookupHistoryItem;
-        },
-  ) {}
-
-  /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
-  static provide({
-    serviceId,
-    preimage,
-    slot,
-  }: {
-    serviceId: ServiceId;
-    preimage: PreimageItem;
-    slot: TimeSlot | null;
-  }) {
-    return new UpdatePreimage(serviceId, {
-      kind: UpdatePreimageKind.Provide,
-      preimage,
-      slot,
-    });
-  }
+type StateView = {
+  /**
 
-  /** The preimage should be removed completely from the database. */
+   * `ρ 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,
+  /** Remove a preimage and it's lookup history. */
+  Remove = 1,
+  /** update or add lookup history for preimage hash/len to given value. */
+  UpdateOrAdd = 2,
+}
+/**
+ * A preimage update.
+ *
+ * Can be one of the following cases:
+ * 1. Provide a new preimage blob and set the lookup history to available at `slot`.
+ * 2. Remove (expunge) a preimage and it's lookup history.
+ * 3. Update `LookupHistory` with given value.
+ */
+declare class UpdatePreimage {
+  private constructor(
+    public readonly serviceId: ServiceId,
+    public readonly action:
+      | {
+          kind: UpdatePreimageKind.Provide;
+          preimage: PreimageItem;
+          // optionally set lookup history of that preimage to "available"
+          slot: TimeSlot | null;
+        }
+      | {
+          kind: UpdatePreimageKind.Remove;
+          hash: PreimageHash;
+          length: U32;
+        }
+      | {
+          kind: UpdatePreimageKind.UpdateOrAdd;
+          item: LookupHistoryItem;
+        },
+  ) {}
+
+  /** A preimage is provided. We should update the lookuphistory and add the preimage to db. */
+  static provide({
+    serviceId,
+    preimage,
+    slot,
+  }: {
+    serviceId: ServiceId;
+    preimage: PreimageItem;
+    slot: TimeSlot | null;
+  }) {
+    return new UpdatePreimage(serviceId, {
+      kind: UpdatePreimageKind.Provide,
+      preimage,
+      slot,
+    });
+  }
+
+  /** The preimage should be removed completely from the database. */
   static remove({ serviceId, hash, length }: { serviceId: ServiceId; hash: PreimageHash; length: U32 }) {
     return new UpdatePreimage(serviceId, {
       kind: UpdatePreimageKind.Remove,
@@ -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>;
 
   /**
@@ -13913,40 +14196,116 @@ interface GasCounter {
   sub(g: Gas): boolean;
 }
 
-/**
- * Mask class is an implementation of skip function defined in GP.
- *
- * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
- */
-declare class Mask {
-  /**
-   * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
-   * In case the value is non-zero it signifies the offset to the index with next instruction.
-   *
-   * Example:
-   * ```
-   * 0..1..2..3..4..5..6..7..8..9 # Indices
-   * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
-   * ```
-   * There are instructions at indices `0, 3, 5, 9`.
-   */
-  private lookupTableForward: Uint8Array;
+declare const NO_OF_REGISTERS$1 = 13;
 
-  constructor(mask: BitVec) {
-    this.lookupTableForward = this.buildLookupTableForward(mask);
+type RegisterIndex = Opaque<number, "register index">;
+
+declare class Registers {
+  private asSigned: BigInt64Array;
+  private asUnsigned: BigUint64Array;
+
+  constructor(private readonly bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
+    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+    this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
+    this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
   }
 
-  isInstruction(index: number) {
-    return this.lookupTableForward[index] === 0;
+  static fromBytes(bytes: Uint8Array) {
+    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+    return new Registers(bytes);
   }
 
-  getNoOfBytesToNextInstruction(index: number) {
-    check`${index >= 0} index (${index}) cannot be a negative number`;
-    return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+  getBytesAsLittleEndian(index: number, len: number) {
+    const offset = index << REGISTER_SIZE_SHIFT;
+    return this.bytes.subarray(offset, offset + len);
   }
 
-  private buildLookupTableForward(mask: BitVec) {
-    const table = safeAllocUint8Array(mask.bitLength);
+  getAllBytesAsLittleEndian() {
+    return this.bytes;
+  }
+
+  copyFrom(regs: Registers | BigUint64Array) {
+    const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
+    this.asUnsigned.set(array);
+  }
+
+  reset() {
+    for (let i = 0; i < NO_OF_REGISTERS; i++) {
+      this.asUnsigned[i] = 0n;
+    }
+  }
+
+  getLowerU32(registerIndex: number) {
+    return Number(this.asUnsigned[registerIndex] & 0xff_ff_ff_ffn);
+  }
+
+  getLowerI32(registerIndex: number) {
+    return Number(this.getLowerU32(registerIndex)) >> 0;
+  }
+
+  setU32(registerIndex: number, value: number) {
+    this.asUnsigned[registerIndex] = signExtend32To64(value);
+  }
+
+  setI32(registerIndex: number, value: number) {
+    this.asSigned[registerIndex] = signExtend32To64(value);
+  }
+
+  getU64(registerIndex: number) {
+    return this.asUnsigned[registerIndex];
+  }
+
+  getI64(registerIndex: number) {
+    return this.asSigned[registerIndex];
+  }
+
+  setU64(registerIndex: number, value: bigint) {
+    this.asUnsigned[registerIndex] = value;
+  }
+
+  setI64(registerIndex: number, value: bigint) {
+    this.asSigned[registerIndex] = value;
+  }
+
+  getAllU64() {
+    return this.asUnsigned;
+  }
+}
+
+/**
+ * Mask class is an implementation of skip function defined in GP.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/237201239801
+ */
+declare class Mask {
+  /**
+   * The lookup table will have `0` at the index which corresponds to an instruction on the same index in the bytecode.
+   * In case the value is non-zero it signifies the offset to the index with next instruction.
+   *
+   * Example:
+   * ```
+   * 0..1..2..3..4..5..6..7..8..9 # Indices
+   * 0..2..1..0..1..0..3..2..1..0 # lookupTable forward values
+   * ```
+   * There are instructions at indices `0, 3, 5, 9`.
+   */
+  private lookupTableForward: Uint8Array;
+
+  constructor(mask: BitVec) {
+    this.lookupTableForward = this.buildLookupTableForward(mask);
+  }
+
+  isInstruction(index: number) {
+    return this.lookupTableForward[index] === 0;
+  }
+
+  getNoOfBytesToNextInstruction(index: number) {
+    check`${index >= 0} index (${index}) cannot be a negative number`;
+    return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
+  }
+
+  private buildLookupTableForward(mask: BitVec) {
+    const table = safeAllocUint8Array(mask.bitLength);
     let lastInstructionOffset = 0;
     for (let i = mask.bitLength - 1; i >= 0; i--) {
       if (mask.isSet(i)) {
@@ -14082,82 +14441,6 @@ declare class ImmediateDecoder {
   }
 }
 
-declare const NO_OF_REGISTERS$1 = 13;
-
-type RegisterIndex = Opaque<number, "register index">;
-
-declare class Registers {
-  private asSigned: BigInt64Array;
-  private asUnsigned: BigUint64Array;
-
-  constructor(private readonly bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-    this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
-    this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
-  }
-
-  static fromBytes(bytes: Uint8Array) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-    return new Registers(bytes);
-  }
-
-  getBytesAsLittleEndian(index: number, len: number) {
-    const offset = index << REGISTER_SIZE_SHIFT;
-    return this.bytes.subarray(offset, offset + len);
-  }
-
-  getAllBytesAsLittleEndian() {
-    return this.bytes;
-  }
-
-  copyFrom(regs: Registers | BigUint64Array) {
-    const array = regs instanceof BigUint64Array ? regs : regs.asUnsigned;
-    this.asUnsigned.set(array);
-  }
-
-  reset() {
-    for (let i = 0; i < NO_OF_REGISTERS; i++) {
-      this.asUnsigned[i] = 0n;
-    }
-  }
-
-  getLowerU32(registerIndex: number) {
-    return Number(this.asUnsigned[registerIndex] & 0xff_ff_ff_ffn);
-  }
-
-  getLowerI32(registerIndex: number) {
-    return Number(this.getLowerU32(registerIndex)) >> 0;
-  }
-
-  setU32(registerIndex: number, value: number) {
-    this.asUnsigned[registerIndex] = signExtend32To64(value);
-  }
-
-  setI32(registerIndex: number, value: number) {
-    this.asSigned[registerIndex] = signExtend32To64(value);
-  }
-
-  getU64(registerIndex: number) {
-    return this.asUnsigned[registerIndex];
-  }
-
-  getI64(registerIndex: number) {
-    return this.asSigned[registerIndex];
-  }
-
-  setU64(registerIndex: number, value: bigint) {
-    this.asUnsigned[registerIndex] = value;
-  }
-
-  setI64(registerIndex: number, value: bigint) {
-    this.asSigned[registerIndex] = value;
-  }
-
-  getAllU64() {
-    return this.asUnsigned;
-  }
-}
-
 declare class NibblesDecoder {
   private byte = new Int8Array(1);
 
@@ -17594,870 +17877,865 @@ declare namespace index$8 {
   export type { index$8_BigGas as BigGas, index$8_Gas as Gas, index$8_GasCounter as GasCounter, index$8_InterpreterOptions as InterpreterOptions, index$8_MemoryIndex as MemoryIndex, index$8_SbrkIndex as SbrkIndex, index$8_SmallGas as SmallGas };
 }
 
-/**
- * Program counter is a 64-bit unsigned integer that points to the next instruction
- *
- * https://graypaper.fluffylabs.dev/#/1c979cb/2e3f012e3f01?v=0.7.1
- */
-type ProgramCounter = Opaque<U64, "ProgramCounter[u64]">;
-/** Convert a number into ProgramCounter. */
-declare const tryAsProgramCounter = (v: number | bigint): ProgramCounter => asOpaqueType(tryAsU64(v));
+interface IHostCallMemory {
+  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds>;
+  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds>;
+}
 
-/** Running PVM instance identifier. */
-type MachineId = Opaque<U64, "MachineId[u64]">;
-/** Convert a number into PVM instance identifier. */
-declare const tryAsMachineId = (v: number | bigint): MachineId => asOpaqueType(tryAsU64(v));
+declare class HostCallMemory implements IHostCallMemory {
+  constructor(private readonly memory: Memory) {}
 
-declare class MachineInstance {
-  async run(gas: BigGas, registers: Registers): Promise<MachineResult> {
-    return {
-      result: {
-        status: Status.OK,
-      },
-      gas,
-      registers,
-    };
-  }
-}
+  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
+    if (bytes.length === 0) {
+      return Result.ok(OK);
+    }
 
-type MachineStatus =
-  | {
-      status: typeof Status.HOST;
-      hostCallIndex: U64;
+    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
+      return Result.error(new OutOfBounds());
     }
-  | {
-      status: typeof Status.FAULT;
-      address: U64;
+
+    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
+  }
+
+  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
+    if (result.length === 0) {
+      return Result.ok(OK);
     }
-  | {
-      status: typeof Status.OK | typeof Status.HALT | typeof Status.PANIC | typeof Status.OOG;
-    };
 
-/** Data returned by a machine invocation. */
-type MachineResult = {
-  result: MachineStatus;
-  gas: BigGas;
-  registers: Registers;
-};
+    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
+      return Result.error(new OutOfBounds());
+    }
 
-/** Types of possbile operations to request by Pages host call. */
-declare enum MemoryOperation {
-  /** Zeroes memory and set access to unreadable. */
-  Void = 0,
-  /** Zeroes memory and set access to read-only. */
-  ZeroRead = 1,
-  /** Zeroes memory and set access to read-write. */
-  ZeroWrite = 2,
-  /** Preserve memory and set access to read-only. */
-  Read = 3,
-  /** Preserve memory and set access to read-write. */
-  Write = 4,
+    return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+  }
 }
 
-/** Convert a number into MemoryOperation or null (if invalid). */
-declare const toMemoryOperation = (v: number | bigint): MemoryOperation | null =>
-  v <= MemoryOperation.Write && v >= MemoryOperation.Void ? Number(v) : null;
-
-/** An error that may occur during `peek` or `poke` host call. */
-declare enum PeekPokeError {
-  /** Source page fault. */
-  SourcePageFault = 0,
-  /** Destination page fault. */
-  DestinationPageFault = 1,
-  /** No machine under given machine index. */
-  NoMachine = 2,
+interface IHostCallRegisters {
+  get(registerIndex: number): U64;
+  set(registerIndex: number, value: U64): void;
 }
 
-declare enum ZeroVoidError {
-  /** No machine under given machine index. */
-  NoMachine = 0,
-  /** Attempting to void or zero non-accessible page. */
-  InvalidPage = 1,
-}
-
-declare enum PagesError {
-  /** No machine under given machine index. */
-  NoMachine = 0,
-  /** Invalid memory operation. */
-  InvalidOperation = 1,
-  /** Attempting to change non-accessible page or trying to preserve value of voided page. */
-  InvalidPage = 2,
-}
+declare class HostCallRegisters implements IHostCallRegisters {
+  constructor(private readonly registers: Registers) {}
 
-/** Error machine is not found. */
-declare const NoMachineError = Symbol("Machine index not found.");
-type NoMachineError = typeof NoMachineError;
+  get(registerIndex: number): U64 {
+    return tryAsU64(this.registers.getU64(registerIndex));
+  }
 
-/** Too many segments already exported. */
-declare const SegmentExportError = Symbol("Too many segments already exported.");
-type SegmentExportError = typeof SegmentExportError;
+  set(registerIndex: number, value: U64) {
+    this.registers.setU64(registerIndex, value);
+  }
+}
 
-/** Host functions external invocations available during refine phase. */
-interface RefineExternalities {
-  /** Forget a previously started nested VM. */
-  machineExpunge(machineIndex: MachineId): Promise<Result$2<ProgramCounter, NoMachineError>>;
+/** Strictly-typed host call index. */
+type HostCallIndex = Opaque<U32, "HostCallIndex[U32]">;
+/** Attempt to convert a number into `HostCallIndex`. */
+declare const tryAsHostCallIndex = (v: number): HostCallIndex => asOpaqueType(tryAsU32(v));
 
-  /** Set given range of pages as non-accessible and re-initialize them with zeros. */
-  machineVoidPages(machineIndex: MachineId, pageStart: U64, pageCount: U64): Promise<Result$2<OK, ZeroVoidError>>;
+/**
+ * Host-call exit reason.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
+ */
+declare enum PvmExecution {
+  Halt = 0,
+  Panic = 1,
+  OOG = 2, // out-of-gas
+}
 
-  /** Set given range of pages as writeable and initialize them with zeros. */
-  machineZeroPages(machineIndex: MachineId, pageStart: U64, pageCount: U64): Promise<Result$2<OK, ZeroVoidError>>;
+/** A utility function to easily trace a bunch of registers. */
+declare function traceRegisters(...regs: number[]) {
+  return regs.map(tryAsRegisterIndex);
+}
 
-  /** Copy a fragment of memory from `machineIndex` into given destination memory. */
-  machinePeekFrom(
-    machineIndex: MachineId,
-    destinationStart: U64,
-    sourceStart: U64,
-    length: U64,
-    destination: Memory,
-  ): Promise<Result$2<OK, PeekPokeError>>;
+/** An interface for a host call implementation */
+interface HostCallHandler {
+  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
+  readonly index: HostCallIndex;
 
-  /** Write a fragment of memory into `machineIndex` from given source memory. */
-  machinePokeInto(
-    machineIndex: MachineId,
-    sourceStart: U64,
-    destinationStart: U64,
-    length: U64,
-    source: Memory,
-  ): Promise<Result$2<OK, PeekPokeError>>;
+  /**
+   * The gas cost of invocation of that host call.
+   *
+   * NOTE: `((reg: IHostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
+   */
+  readonly basicGasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
 
-  /** Start an inner PVM instance with given entry point and starting code. */
-  machineInit(code: BytesBlob, programCounter: ProgramCounter): Promise<Result$2<MachineId, ProgramDecoderError>>;
+  /** Currently executing service id. */
+  readonly currentServiceId: U32;
 
-  /** Run a previously initialized PVM instance with given gas and registers. */
-  machineInvoke(
-    machineIndex: MachineId,
-    gas: BigGas,
-    registers: Registers,
-  ): Promise<Result$2<MachineResult, NoMachineError>>;
+  /** Input&Output registers that we should add to tracing log. */
+  readonly tracedRegisters: RegisterIndex[];
 
   /**
-   * Export segment for future retrieval.
+   * Actually execute the host call.
    *
-   * Returns the index assigned to that segment or an error if there is too many already exported.
+   * NOTE the call is ALLOWED and expected to modify registers and memory.
    */
-  exportSegment(segment: Segment): Result$2<SegmentIndex, SegmentExportError>;
-
-  /** Lookup a historical preimage. */
-  historicalLookup(serviceId: ServiceId | null, hash: Blake2bHash): Promise<BytesBlob | null>;
-
-  /** Change access to and/or zero the value of memory. */
-  machinePages(
-    machineIndex: MachineId,
-    pageStart: U64,
-    pageCount: U64,
-    requestType: MemoryOperation | null,
-  ): Promise<Result$2<OK, PagesError>>;
+  execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
 }
 
-declare const InsufficientFundsError = "insufficient funds";
-type InsufficientFundsError = typeof InsufficientFundsError;
-
-/** Update of the state entries coming from accumulation of a single service. */
-type ServiceStateUpdate = Partial<Pick<State, "privilegedServices" | "authQueues" | "designatedValidatorData">> &
-  ServicesUpdate;
+/** Container for all available host calls. */
+declare class HostCallsManager {
+  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
+  private readonly missing;
 
-/**
- * State updates that currently accumulating service produced.
- *
- * `x_u`: https://graypaper.fluffylabs.dev/#/9a08063/2f31012f3101?v=0.6.6
- */
-declare class AccumulationStateUpdate {
-  /** Updated authorization queues for cores. */
-  public readonly authorizationQueues: Map<CoreIndex, FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>> =
-    new Map();
-  /** New validators data. */
-  public validatorsData: PerValidator<ValidatorData> | null = null;
-  /** Updated priviliged services. */
-  public privilegedServices: PrivilegedServices | null = null;
+  constructor({
+    missing,
+    handlers = [],
+  }: {
+    missing: HostCallHandler;
+    handlers?: HostCallHandler[];
+  }) {
+    this.missing = missing;
 
-  private constructor(
-    /** Services state updates. */
-    public readonly services: ServicesUpdate,
-    /** Pending transfers. */
-    public transfers: PendingTransfer[],
-    /** Yielded accumulation root. */
-    public readonly yieldedRoots: Map<ServiceId, OpaqueHash> = new Map(),
-  ) {}
+    for (const handler of handlers) {
+      check`${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
+      this.hostCalls.set(handler.index, handler);
+    }
+  }
 
-  /** Create new empty state update. */
-  static empty(): AccumulationStateUpdate {
-    return new AccumulationStateUpdate(
-      {
-        servicesUpdates: [],
-        servicesRemoved: [],
-        preimages: [],
-        storage: [],
-      },
-      [],
-    );
+  /** Get a host call by index. */
+  get(hostCallIndex: HostCallIndex): HostCallHandler {
+    return this.hostCalls.get(hostCallIndex) ?? this.missing;
   }
 
-  /** Create a state update with some existing, yet uncommited services updates. */
-  static new(update: ServicesUpdate): AccumulationStateUpdate {
-    return new AccumulationStateUpdate(
-      {
-        ...update,
-      },
-      [],
-    );
+  traceHostCall(
+    context: string,
+    hostCallIndex: HostCallIndex,
+    hostCallHandler: HostCallHandler,
+    registers: IHostCallRegisters,
+    gas: Gas,
+  ) {
+    const { currentServiceId } = hostCallHandler;
+    const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
+    const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
+    const registerValues = hostCallHandler.tracedRegisters
+      .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)] as const)
+      .filter((v) => v[1] !== 0n)
+      .map(([idx, value]) => {
+        return `r${idx}=${value} (0x${value.toString(16)})`;
+      })
+      .join(", ");
+    logger.insane`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
   }
+}
 
-  /** Create a copy of another `StateUpdate`. Used by checkpoints. */
-  static copyFrom(from: AccumulationStateUpdate): AccumulationStateUpdate {
-    const serviceUpdates: ServicesUpdate = {
-      servicesUpdates: [...from.services.servicesUpdates],
-      servicesRemoved: [...from.services.servicesRemoved],
-      preimages: [...from.services.preimages],
-      storage: [...from.services.storage],
-    };
-    const transfers = [...from.transfers];
-    const update = new AccumulationStateUpdate(serviceUpdates, transfers, new Map(from.yieldedRoots));
+type ResolveFn = (pvm: Interpreter) => void;
 
-    // update entries
-    for (const [k, v] of from.authorizationQueues) {
-      update.authorizationQueues.set(k, v);
-    }
+declare class InterpreterInstanceManager {
+  private instances: Interpreter[] = [];
+  private waitingQueue: ResolveFn[] = [];
 
-    if (from.validatorsData !== null) {
-      update.validatorsData = asKnownSize([...from.validatorsData]);
+  constructor(noOfPvmInstances: number) {
+    for (let i = 0; i < noOfPvmInstances; i++) {
+      this.instances.push(
+        new Interpreter({
+          useSbrkGas: false,
+        }),
+      );
     }
+  }
 
-    if (from.privilegedServices !== null) {
-      update.privilegedServices = PrivilegedServices.create({
-        ...from.privilegedServices,
-        assigners: asKnownSize([...from.privilegedServices.assigners]),
-      });
+  async getInstance(): Promise<Interpreter> {
+    const instance = this.instances.pop();
+    if (instance !== undefined) {
+      return Promise.resolve(instance);
     }
-    return update;
+    return new Promise((resolve) => {
+      this.waitingQueue.push(resolve);
+    });
   }
 
-  /** Retrieve and clear pending transfers. */
-  takeTransfers() {
-    const transfers = this.transfers;
-    this.transfers = [];
-    return transfers;
+  releaseInstance(pvm: Interpreter) {
+    const waiting = this.waitingQueue.shift();
+    if (waiting !== undefined) {
+      return waiting(pvm);
+    }
+    this.instances.push(pvm);
   }
 }
 
-type StateSlice = Pick<State, "getService" | "privilegedServices">;
+declare class ReturnValue {
+  private constructor(
+    public consumedGas: Gas,
+    public status: Status | null,
+    public memorySlice: Uint8Array | null,
+  ) {
+    check`
+      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
+      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
+    `;
+  }
 
-declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
-  /** A collection of state updates. */
-  public readonly stateUpdate;
-
-  constructor(
-    /** Original (unmodified state). */
-    public readonly state: T,
-    stateUpdate?: AccumulationStateUpdate,
-  ) {
-    this.stateUpdate =
-      stateUpdate === undefined ? AccumulationStateUpdate.empty() : AccumulationStateUpdate.copyFrom(stateUpdate);
+  static fromStatus(consumedGas: Gas, status: Status) {
+    return new ReturnValue(consumedGas, status, null);
   }
 
-  /**
-   * Retrieve info of service with given id.
-   *
-   * NOTE the info may be updated compared to what is in the state.
-   *
-   * Takes into account ejected and newly created services as well.
-   */
-  getServiceInfo(destination: ServiceId | null): ServiceAccountInfo | null {
-    if (destination === null) {
-      return null;
-    }
-
-    const maybeNewService = this.stateUpdate.services.servicesUpdates.find(
-      (update) => update.serviceId === destination,
-    );
-
-    if (maybeNewService !== undefined) {
-      return maybeNewService.action.account;
-    }
-
-    const maybeService = this.state.getService(destination);
-    if (maybeService === null) {
-      return null;
-    }
-
-    return maybeService.getInfo();
+  static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array) {
+    return new ReturnValue(consumedGas, null, memorySlice);
   }
 
-  getStorage(serviceId: ServiceId, rawKey: StorageKey): BytesBlob | null {
-    const item = this.stateUpdate.services.storage.find((x) => x.serviceId === serviceId && x.key.isEqualTo(rawKey));
-    if (item !== undefined) {
-      return item.value;
-    }
+  hasMemorySlice(): this is this & { status: null; memorySlice: Uint8Array } {
+    return this.memorySlice instanceof Uint8Array && this.status === null;
+  }
 
-    const service = this.state.getService(serviceId);
-    return service?.getStorage(rawKey) ?? null;
+  hasStatus(): this is this & { status: Status; memorySlice: null } {
+    return !this.hasMemorySlice();
   }
+}
+declare class HostCalls {
+  constructor(
+    private pvmInstanceManager: InterpreterInstanceManager,
+    private hostCalls: HostCallsManager,
+  ) {}
 
-  /**
-   * Returns `true` if the preimage is already provided either in current
-   * accumulation scope or earlier.
-   *
-   * NOTE: Does not check if the preimage is available, we just check
-   * the existence in `preimages` map.
-   */
-  hasPreimage(serviceId: ServiceId, hash: PreimageHash): boolean {
-    const providedPreimage = this.stateUpdate.services.preimages.find(
-      // we ignore the action here, since if there is <any> update on that
-      // hash it means it has to exist, right?
-      (p) => p.serviceId === serviceId && p.hash.isEqualTo(hash),
-    );
-    if (providedPreimage !== undefined) {
-      return true;
+  private getReturnValue(status: Status, pvmInstance: Interpreter): ReturnValue {
+    const gasConsumed = pvmInstance.getGasConsumed();
+    if (status === Status.OOG) {
+      return ReturnValue.fromStatus(gasConsumed, status);
     }
 
-    // fallback to state preimages
-    const service = this.state.getService(serviceId);
-    if (service === undefined) {
-      return false;
-    }
+    if (status === Status.HALT) {
+      const memory = pvmInstance.getMemory();
+      const regs = pvmInstance.getRegisters();
+      const maybeAddress = regs.getLowerU32(7);
+      const maybeLength = regs.getLowerU32(8);
 
-    return service?.hasPreimage(hash) ?? false;
-  }
+      const result = safeAllocUint8Array(maybeLength);
+      const startAddress = tryAsMemoryIndex(maybeAddress);
+      const loadResult = memory.loadInto(result, startAddress);
 
-  getPreimage(serviceId: ServiceId, hash: PreimageHash): BytesBlob | null {
-    // TODO [ToDr] Should we verify availability here?
-    const freshlyProvided = this.stateUpdate.services.preimages.find(
-      (x) => x.serviceId === serviceId && x.hash.isEqualTo(hash),
-    );
-    if (freshlyProvided !== undefined && freshlyProvided.action.kind === UpdatePreimageKind.Provide) {
-      return freshlyProvided.action.preimage.blob;
+      if (loadResult.isError) {
+        return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
+      }
+
+      return ReturnValue.fromMemorySlice(gasConsumed, result);
     }
 
-    const service = this.state.getService(serviceId);
-    return service?.getPreimage(hash) ?? null;
+    return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
   }
 
-  /** Get status of a preimage of current service taking into account any updates. */
-  getLookupHistory(
-    currentTimeslot: TimeSlot,
-    serviceId: ServiceId,
-    hash: PreimageHash,
-    length: U64,
-  ): LookupHistoryItem | null {
-    // TODO [ToDr] This is most likely wrong. We may have `provide` and `remove` within
-    // the same state update. We should however switch to proper "updated state"
-    // representation soon.
-    const updatedPreimage = this.stateUpdate.services.preimages.findLast(
-      (update) => update.serviceId === serviceId && update.hash.isEqualTo(hash) && BigInt(update.length) === length,
-    );
-
-    const stateFallback = () => {
-      // fallback to state lookup
-      const service = this.state.getService(serviceId);
-      const lenU32 = preimageLenAsU32(length);
-      if (lenU32 === null || service === null) {
-        return null;
+  private async execute(pvmInstance: Interpreter) {
+    pvmInstance.runProgram();
+    for (;;) {
+      let status = pvmInstance.getStatus();
+      if (status !== Status.HOST) {
+        return this.getReturnValue(status, pvmInstance);
       }
+      check`
+        ${pvmInstance.getExitParam() !== null}
+        "We know that the exit param is not null, because the status is 'Status.HOST'
+      `;
+      const hostCallIndex = pvmInstance.getExitParam() ?? -1;
+      const gas = pvmInstance.getGasCounter();
+      const regs = new HostCallRegisters(pvmInstance.getRegisters());
+      const memory = new HostCallMemory(pvmInstance.getMemory());
+      const index = tryAsHostCallIndex(hostCallIndex);
 
-      const slots = service.getLookupHistory(hash, lenU32);
-      return slots === null ? null : new LookupHistoryItem(hash, lenU32, slots);
-    };
-
-    if (updatedPreimage === undefined) {
-      return stateFallback();
-    }
+      const hostCall = this.hostCalls.get(index);
+      const gasBefore = gas.get();
+      // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+      const basicGasCost =
+        typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
+      const underflow = gas.sub(basicGasCost);
 
-    const { action } = updatedPreimage;
-    switch (action.kind) {
-      case UpdatePreimageKind.Provide: {
-        // casting to U32 is safe, since we compare with object we have in memory.
-        return new LookupHistoryItem(hash, updatedPreimage.length, tryAsLookupHistorySlots([currentTimeslot]));
+      const pcLog = `[PC: ${pvmInstance.getPC()}]`;
+      if (underflow) {
+        this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
+        return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
       }
-      case UpdatePreimageKind.Remove: {
-        const state = stateFallback();
-        // kinda impossible, since we know it's there because it's removed.
-        if (state === null) {
-          return null;
-        }
+      this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
+      const result = await hostCall.execute(gas, regs, memory);
+      this.hostCalls.traceHostCall(
+        result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`,
+        index,
+        hostCall,
+        regs,
+        gas.get(),
+      );
 
-        return new LookupHistoryItem(hash, state.length, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
-      }
-      case UpdatePreimageKind.UpdateOrAdd: {
-        return action.item;
+      if (result === PvmExecution.Halt) {
+        status = Status.HALT;
+        return this.getReturnValue(status, pvmInstance);
       }
-    }
 
-    assertNever(action);
-  }
+      if (result === PvmExecution.Panic) {
+        status = Status.PANIC;
+        return this.getReturnValue(status, pvmInstance);
+      }
 
-  /* State update functions. */
+      if (result === PvmExecution.OOG) {
+        status = Status.OOG;
+        return this.getReturnValue(status, pvmInstance);
+      }
 
-  updateStorage(serviceId: ServiceId, key: StorageKey, value: BytesBlob | null) {
-    const update =
-      value === null
-        ? UpdateStorage.remove({ serviceId, key })
-        : UpdateStorage.set({
-            serviceId,
-            storage: StorageItem.create({ key, value }),
-          });
+      if (result === undefined) {
+        pvmInstance.runProgram();
+        status = pvmInstance.getStatus();
+        continue;
+      }
 
-    const index = this.stateUpdate.services.storage.findIndex(
-      (x) => x.serviceId === update.serviceId && x.key.isEqualTo(key),
-    );
-    const count = index === -1 ? 0 : 1;
-    this.stateUpdate.services.storage.splice(index, count, update);
+      assertNever(result);
+    }
   }
 
-  /**
-   * Update a preimage.
-   *
-   * Note we store all previous entries as well, since there might be a sequence of:
-   * `provide` -> `remove` and both should update the end state somehow.
-   */
-  updatePreimage(newUpdate: UpdatePreimage) {
-    this.stateUpdate.services.preimages.push(newUpdate);
+  async runProgram(
+    rawProgram: Uint8Array,
+    initialPc: number,
+    initialGas: Gas,
+    maybeRegisters?: Registers,
+    maybeMemory?: Memory,
+  ): Promise<ReturnValue> {
+    const pvmInstance = await this.pvmInstanceManager.getInstance();
+    pvmInstance.reset(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory);
+    try {
+      return await this.execute(pvmInstance);
+    } finally {
+      this.pvmInstanceManager.releaseInstance(pvmInstance);
+    }
   }
+}
 
-  updateServiceStorageUtilisation(
-    serviceId: ServiceId,
-    items: number,
-    bytes: bigint,
-    serviceInfo: ServiceAccountInfo,
-  ): Result$2<OK, InsufficientFundsError> {
-    check`${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
-    check`${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
-
-    const overflowItems = !isU32(items);
-    const overflowBytes = !isU64(bytes);
-
-    // TODO [ToDr] this is not specified in GP, but it seems sensible.
-    if (overflowItems || overflowBytes) {
-      return Result.error(InsufficientFundsError);
-    }
+type index$7_HostCallHandler = HostCallHandler;
+type index$7_HostCallMemory = HostCallMemory;
+declare const index$7_HostCallMemory: typeof HostCallMemory;
+type index$7_HostCallRegisters = HostCallRegisters;
+declare const index$7_HostCallRegisters: typeof HostCallRegisters;
+type index$7_IHostCallMemory = IHostCallMemory;
+type index$7_IHostCallRegisters = IHostCallRegisters;
+type index$7_PvmExecution = PvmExecution;
+declare const index$7_PvmExecution: typeof PvmExecution;
+declare const index$7_traceRegisters: typeof traceRegisters;
+declare const index$7_tryAsHostCallIndex: typeof tryAsHostCallIndex;
+declare namespace index$7 {
+  export { index$7_HostCallMemory as HostCallMemory, index$7_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$7_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$7_traceRegisters as traceRegisters, index$7_tryAsHostCallIndex as tryAsHostCallIndex };
+  export type { index$7_HostCallHandler as HostCallHandler, index$7_IHostCallMemory as IHostCallMemory, index$7_IHostCallRegisters as IHostCallRegisters };
+}
 
-    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
-    if (serviceInfo.balance < thresholdBalance) {
-      return Result.error(InsufficientFundsError);
-    }
+/**
+ * Program counter is a 64-bit unsigned integer that points to the next instruction
+ *
+ * https://graypaper.fluffylabs.dev/#/1c979cb/2e3f012e3f01?v=0.7.1
+ */
+type ProgramCounter = Opaque<U64, "ProgramCounter[u64]">;
+/** Convert a number into ProgramCounter. */
+declare const tryAsProgramCounter = (v: number | bigint): ProgramCounter => asOpaqueType(tryAsU64(v));
 
-    // Update service info with new details.
-    this.updateServiceInfo(
-      serviceId,
-      ServiceAccountInfo.create({
-        ...serviceInfo,
-        storageUtilisationBytes: bytes,
-        storageUtilisationCount: items,
-      }),
-    );
-    return Result.ok(OK);
+/** Running PVM instance identifier. */
+type MachineId = Opaque<U64, "MachineId[u64]">;
+/** Convert a number into PVM instance identifier. */
+declare const tryAsMachineId = (v: number | bigint): MachineId => asOpaqueType(tryAsU64(v));
+
+declare class MachineInstance {
+  async run(gas: BigGas, registers: Registers): Promise<MachineResult> {
+    return {
+      result: {
+        status: Status.OK,
+      },
+      gas,
+      registers,
+    };
   }
+}
 
-  updateServiceInfo(serviceId: ServiceId, newInfo: ServiceAccountInfo) {
-    const idx = this.stateUpdate.services.servicesUpdates.findIndex((x) => x.serviceId === serviceId);
-    const toRemove = idx === -1 ? 0 : 1;
-    const existingItem = this.stateUpdate.services.servicesUpdates[idx];
+type MachineStatus =
+  | {
+      status: typeof Status.HOST;
+      hostCallIndex: U64;
+    }
+  | {
+      status: typeof Status.FAULT;
+      address: U64;
+    }
+  | {
+      status: typeof Status.OK | typeof Status.HALT | typeof Status.PANIC | typeof Status.OOG;
+    };
 
-    if (existingItem?.action.kind === UpdateServiceKind.Create) {
-      this.stateUpdate.services.servicesUpdates.splice(
-        idx,
-        toRemove,
-        UpdateService.create({
-          serviceId,
-          serviceInfo: newInfo,
-          lookupHistory: existingItem.action.lookupHistory,
-        }),
-      );
+/** Data returned by a machine invocation. */
+type MachineResult = {
+  result: MachineStatus;
+  gas: BigGas;
+  registers: Registers;
+};
 
-      return;
-    }
+/** Types of possbile operations to request by Pages host call. */
+declare enum MemoryOperation {
+  /** Zeroes memory and set access to unreadable. */
+  Void = 0,
+  /** Zeroes memory and set access to read-only. */
+  ZeroRead = 1,
+  /** Zeroes memory and set access to read-write. */
+  ZeroWrite = 2,
+  /** Preserve memory and set access to read-only. */
+  Read = 3,
+  /** Preserve memory and set access to read-write. */
+  Write = 4,
+}
 
-    this.stateUpdate.services.servicesUpdates.splice(
-      idx,
-      toRemove,
-      UpdateService.update({
-        serviceId,
-        serviceInfo: newInfo,
-      }),
-    );
-  }
+/** Convert a number into MemoryOperation or null (if invalid). */
+declare const toMemoryOperation = (v: number | bigint): MemoryOperation | null =>
+  v <= MemoryOperation.Write && v >= MemoryOperation.Void ? Number(v) : null;
 
-  getPrivilegedServices() {
-    if (this.stateUpdate.privilegedServices !== null) {
-      return this.stateUpdate.privilegedServices;
-    }
+/** An error that may occur during `peek` or `poke` host call. */
+declare enum PeekPokeError {
+  /** Source page fault. */
+  SourcePageFault = 0,
+  /** Destination page fault. */
+  DestinationPageFault = 1,
+  /** No machine under given machine index. */
+  NoMachine = 2,
+}
 
-    return this.state.privilegedServices;
-  }
+declare enum ZeroVoidError {
+  /** No machine under given machine index. */
+  NoMachine = 0,
+  /** Attempting to void or zero non-accessible page. */
+  InvalidPage = 1,
 }
 
-declare function preimageLenAsU32(length: U64) {
-  // Safe to convert to Number and U32: we check that len < 2^32 before conversion
-  return length >= 2n ** 32n ? null : tryAsU32(Number(length));
+declare enum PagesError {
+  /** No machine under given machine index. */
+  NoMachine = 0,
+  /** Invalid memory operation. */
+  InvalidOperation = 1,
+  /** Attempting to change non-accessible page or trying to preserve value of voided page. */
+  InvalidPage = 2,
 }
 
-/**
- * Host call result constants.
- *
- * https://graypaper.fluffylabs.dev/#/85129da/2c7c022c7c02?v=0.6.3
- */
-declare const HostCallResult = {
-  /** The return value indicating an item does not exist. */
-  NONE: tryAsU64(0xffff_ffff_ffff_ffffn), // 2**64 - 1
-  /** Name unknown. */
-  WHAT: tryAsU64(0xffff_ffff_ffff_fffen), // 2**64 - 2
-  /** The inner PVM memory index provided for reading/writing is not accessible. */
-  OOB: tryAsU64(0xffff_ffff_ffff_fffdn), // 2**64 - 3
-  /** Index unknown. */
-  WHO: tryAsU64(0xffff_ffff_ffff_fffcn), // 2**64 - 4
-  /** Storage full or resource already allocated. */
-  FULL: tryAsU64(0xffff_ffff_ffff_fffbn), // 2**64 - 5
-  /** Core index unknown. */
-  CORE: tryAsU64(0xffff_ffff_ffff_fffan), // 2**64 - 6
-  /** Insufficient funds. */
-  CASH: tryAsU64(0xffff_ffff_ffff_fff9n), // 2**64 - 7
-  /** Gas limit too low. */
-  LOW: tryAsU64(0xffff_ffff_ffff_fff8n), // 2**64 - 8
-  /** The item is already solicited, cannot be forgotten or the operation is invalid due to privilege level. */
-  HUH: tryAsU64(0xffff_ffff_ffff_fff7n), // 2**64 - 9
-  /** The return value indicating general success. */
-  OK: tryAsU64(0n),
-} as const;
+/** Error machine is not found. */
+declare const NoMachineError = Symbol("Machine index not found.");
+type NoMachineError = typeof NoMachineError;
 
-interface IHostCallMemory {
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds>;
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds>;
-  getMemory(): Memory;
+/** Too many segments already exported. */
+declare const SegmentExportError = Symbol("Too many segments already exported.");
+type SegmentExportError = typeof SegmentExportError;
+
+/** Host functions external invocations available during refine phase. */
+interface RefineExternalities {
+  /** Forget a previously started nested VM. */
+  machineExpunge(machineIndex: MachineId): Promise<Result$2<ProgramCounter, NoMachineError>>;
+
+  /** Set given range of pages as non-accessible and re-initialize them with zeros. */
+  machineVoidPages(machineIndex: MachineId, pageStart: U64, pageCount: U64): Promise<Result$2<OK, ZeroVoidError>>;
+
+  /** Set given range of pages as writeable and initialize them with zeros. */
+  machineZeroPages(machineIndex: MachineId, pageStart: U64, pageCount: U64): Promise<Result$2<OK, ZeroVoidError>>;
+
+  /** Copy a fragment of memory from `machineIndex` into given destination memory. */
+  machinePeekFrom(
+    machineIndex: MachineId,
+    destinationStart: U64,
+    sourceStart: U64,
+    length: U64,
+    destination: IHostCallMemory,
+  ): Promise<Result$2<OK, PeekPokeError>>;
+
+  /** Write a fragment of memory into `machineIndex` from given source memory. */
+  machinePokeInto(
+    machineIndex: MachineId,
+    sourceStart: U64,
+    destinationStart: U64,
+    length: U64,
+    source: IHostCallMemory,
+  ): Promise<Result$2<OK, PeekPokeError>>;
+
+  /** Start an inner PVM instance with given entry point and starting code. */
+  machineInit(code: BytesBlob, programCounter: ProgramCounter): Promise<Result$2<MachineId, ProgramDecoderError>>;
+
+  /** Run a previously initialized PVM instance with given gas and registers. */
+  machineInvoke(
+    machineIndex: MachineId,
+    gas: BigGas,
+    registers: Registers,
+  ): Promise<Result$2<MachineResult, NoMachineError>>;
+
+  /**
+   * Export segment for future retrieval.
+   *
+   * Returns the index assigned to that segment or an error if there is too many already exported.
+   */
+  exportSegment(segment: Segment): Result$2<SegmentIndex, SegmentExportError>;
+
+  /** Lookup a historical preimage. */
+  historicalLookup(serviceId: ServiceId | null, hash: Blake2bHash): Promise<BytesBlob | null>;
+
+  /** Change access to and/or zero the value of memory. */
+  machinePages(
+    machineIndex: MachineId,
+    pageStart: U64,
+    pageCount: U64,
+    requestType: MemoryOperation | null,
+  ): Promise<Result$2<OK, PagesError>>;
 }
 
-declare class HostCallMemory implements IHostCallMemory {
-  constructor(private readonly memory: Memory) {}
+declare const InsufficientFundsError = "insufficient funds";
+type InsufficientFundsError = typeof InsufficientFundsError;
 
-  storeFrom(address: U64, bytes: Uint8Array): Result$2<OK, PageFault | OutOfBounds> {
-    if (bytes.length === 0) {
-      return Result.ok(OK);
-    }
+/** Update of the state entries coming from accumulation of a single service. */
+type ServiceStateUpdate = Partial<Pick<State, "privilegedServices" | "authQueues" | "designatedValidatorData">> &
+  ServicesUpdate;
 
-    if (address + tryAsU64(bytes.length) > MEMORY_SIZE) {
-      return Result.error(new OutOfBounds());
-    }
+/**
+ * State updates that currently accumulating service produced.
+ *
+ * `x_u`: https://graypaper.fluffylabs.dev/#/9a08063/2f31012f3101?v=0.6.6
+ */
+declare class AccumulationStateUpdate {
+  /** Updated authorization queues for cores. */
+  public readonly authorizationQueues: Map<CoreIndex, FixedSizeArray<AuthorizerHash, AUTHORIZATION_QUEUE_SIZE>> =
+    new Map();
+  /** New validators data. */
+  public validatorsData: PerValidator<ValidatorData> | null = null;
+  /** Updated priviliged services. */
+  public privilegedServices: PrivilegedServices | null = null;
 
-    return this.memory.storeFrom(tryAsMemoryIndex(Number(address)), bytes);
+  private constructor(
+    /** Services state updates. */
+    public readonly services: ServicesUpdate,
+    /** Pending transfers. */
+    public transfers: PendingTransfer[],
+    /** Yielded accumulation root. */
+    public readonly yieldedRoots: Map<ServiceId, OpaqueHash> = new Map(),
+  ) {}
+
+  /** Create new empty state update. */
+  static empty(): AccumulationStateUpdate {
+    return new AccumulationStateUpdate(
+      {
+        servicesUpdates: [],
+        servicesRemoved: [],
+        preimages: [],
+        storage: [],
+      },
+      [],
+    );
+  }
+
+  /** Create a state update with some existing, yet uncommited services updates. */
+  static new(update: ServicesUpdate): AccumulationStateUpdate {
+    return new AccumulationStateUpdate(
+      {
+        ...update,
+      },
+      [],
+    );
   }
 
-  loadInto(result: Uint8Array, startAddress: U64): Result$2<OK, PageFault | OutOfBounds> {
-    if (result.length === 0) {
-      return Result.ok(OK);
+  /** Create a copy of another `StateUpdate`. Used by checkpoints. */
+  static copyFrom(from: AccumulationStateUpdate): AccumulationStateUpdate {
+    const serviceUpdates: ServicesUpdate = {
+      servicesUpdates: [...from.services.servicesUpdates],
+      servicesRemoved: [...from.services.servicesRemoved],
+      preimages: [...from.services.preimages],
+      storage: [...from.services.storage],
+    };
+    const transfers = [...from.transfers];
+    const update = new AccumulationStateUpdate(serviceUpdates, transfers, new Map(from.yieldedRoots));
+
+    // update entries
+    for (const [k, v] of from.authorizationQueues) {
+      update.authorizationQueues.set(k, v);
     }
 
-    if (startAddress + tryAsU64(result.length) > MEMORY_SIZE) {
-      return Result.error(new OutOfBounds());
+    if (from.validatorsData !== null) {
+      update.validatorsData = asKnownSize([...from.validatorsData]);
     }
 
-    return this.memory.loadInto(result, tryAsMemoryIndex(Number(startAddress)));
+    if (from.privilegedServices !== null) {
+      update.privilegedServices = PrivilegedServices.create({
+        ...from.privilegedServices,
+        assigners: asKnownSize([...from.privilegedServices.assigners]),
+      });
+    }
+    return update;
   }
 
-  getMemory(): Memory {
-    return this.memory;
+  /** Retrieve and clear pending transfers. */
+  takeTransfers() {
+    const transfers = this.transfers;
+    this.transfers = [];
+    return transfers;
   }
 }
 
-interface IHostCallRegisters {
-  get(registerIndex: number): U64;
-  set(registerIndex: number, value: U64): void;
-}
-
-declare class HostCallRegisters implements IHostCallRegisters {
-  constructor(private readonly registers: Registers) {}
+type StateSlice = Pick<State, "getService" | "privilegedServices">;
 
-  get(registerIndex: number): U64 {
-    return tryAsU64(this.registers.getU64(registerIndex));
-  }
+declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
+  /** A collection of state updates. */
+  public readonly stateUpdate;
 
-  set(registerIndex: number, value: U64) {
-    this.registers.setU64(registerIndex, value);
+  constructor(
+    /** Original (unmodified state). */
+    public readonly state: T,
+    stateUpdate?: AccumulationStateUpdate,
+  ) {
+    this.stateUpdate =
+      stateUpdate === undefined ? AccumulationStateUpdate.empty() : AccumulationStateUpdate.copyFrom(stateUpdate);
   }
-}
 
-/** Strictly-typed host call index. */
-type HostCallIndex = Opaque<U32, "HostCallIndex[U32]">;
-/** Attempt to convert a number into `HostCallIndex`. */
-declare const tryAsHostCallIndex = (v: number): HostCallIndex => asOpaqueType(tryAsU32(v));
+  /**
+   * Retrieve info of service with given id.
+   *
+   * NOTE the info may be updated compared to what is in the state.
+   *
+   * Takes into account ejected and newly created services as well.
+   */
+  getServiceInfo(destination: ServiceId | null): ServiceAccountInfo | null {
+    if (destination === null) {
+      return null;
+    }
 
-/**
- * Host-call exit reason.
- *
- * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
- */
-declare enum PvmExecution {
-  Halt = 0,
-  Panic = 1,
-  OOG = 2, // out-of-gas
-}
+    const maybeNewService = this.stateUpdate.services.servicesUpdates.find(
+      (update) => update.serviceId === destination,
+    );
 
-/** A utility function to easily trace a bunch of registers. */
-declare function traceRegisters(...regs: number[]) {
-  return regs.map(tryAsRegisterIndex);
-}
+    if (maybeNewService !== undefined) {
+      return maybeNewService.action.account;
+    }
 
-/** An interface for a host call implementation */
-interface HostCallHandler {
-  /** Index of that host call (i.e. what PVM invokes via `ecalli`) */
-  readonly index: HostCallIndex;
+    const maybeService = this.state.getService(destination);
+    if (maybeService === null) {
+      return null;
+    }
 
-  /**
-   * The gas cost of invocation of that host call.
-   *
-   * NOTE: `((reg: IHostCallRegisters) => Gas)` function is for compatibility reasons: pre GP 0.7.2
-   */
-  readonly basicGasCost: SmallGas | ((reg: IHostCallRegisters) => Gas);
+    return maybeService.getInfo();
+  }
 
-  /** Currently executing service id. */
-  readonly currentServiceId: U32;
+  getStorage(serviceId: ServiceId, rawKey: StorageKey): BytesBlob | null {
+    const item = this.stateUpdate.services.storage.find((x) => x.serviceId === serviceId && x.key.isEqualTo(rawKey));
+    if (item !== undefined) {
+      return item.value;
+    }
 
-  /** Input&Output registers that we should add to tracing log. */
-  readonly tracedRegisters: RegisterIndex[];
+    const service = this.state.getService(serviceId);
+    return service?.getStorage(rawKey) ?? null;
+  }
 
   /**
-   * Actually execute the host call.
+   * Returns `true` if the preimage is already provided either in current
+   * accumulation scope or earlier.
    *
-   * NOTE the call is ALLOWED and expected to modify registers and memory.
+   * NOTE: Does not check if the preimage is available, we just check
+   * the existence in `preimages` map.
    */
-  execute(gas: GasCounter, regs: IHostCallRegisters, memory: IHostCallMemory): Promise<undefined | PvmExecution>;
-}
-
-/** Container for all available host calls. */
-declare class HostCallsManager {
-  private readonly hostCalls = new Map<HostCallIndex, HostCallHandler>();
-  private readonly missing;
-
-  constructor({
-    missing,
-    handlers = [],
-  }: {
-    missing: HostCallHandler;
-    handlers?: HostCallHandler[];
-  }) {
-    this.missing = missing;
+  hasPreimage(serviceId: ServiceId, hash: PreimageHash): boolean {
+    const providedPreimage = this.stateUpdate.services.preimages.find(
+      // we ignore the action here, since if there is <any> update on that
+      // hash it means it has to exist, right?
+      (p) => p.serviceId === serviceId && p.hash.isEqualTo(hash),
+    );
+    if (providedPreimage !== undefined) {
+      return true;
+    }
 
-    for (const handler of handlers) {
-      check`${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
-      this.hostCalls.set(handler.index, handler);
+    // fallback to state preimages
+    const service = this.state.getService(serviceId);
+    if (service === undefined) {
+      return false;
     }
-  }
 
-  /** Get a host call by index. */
-  get(hostCallIndex: HostCallIndex): HostCallHandler {
-    return this.hostCalls.get(hostCallIndex) ?? this.missing;
+    return service?.hasPreimage(hash) ?? false;
   }
 
-  traceHostCall(
-    context: string,
-    hostCallIndex: HostCallIndex,
-    hostCallHandler: HostCallHandler,
-    registers: IHostCallRegisters,
-    gas: Gas,
-  ) {
-    const { currentServiceId } = hostCallHandler;
-    const requested = hostCallIndex !== hostCallHandler.index ? ` (${hostCallIndex})` : "";
-    const name = `${hostCallHandler.constructor.name}:${hostCallHandler.index}`;
-    const registerValues = hostCallHandler.tracedRegisters
-      .map((idx) => [idx.toString().padStart(2, "0"), registers.get(idx)] as const)
-      .filter((v) => v[1] !== 0n)
-      .map(([idx, value]) => {
-        return `r${idx}=${value} (0x${value.toString(16)})`;
-      })
-      .join(", ");
-    logger.insane`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+  getPreimage(serviceId: ServiceId, hash: PreimageHash): BytesBlob | null {
+    // TODO [ToDr] Should we verify availability here?
+    const freshlyProvided = this.stateUpdate.services.preimages.find(
+      (x) => x.serviceId === serviceId && x.hash.isEqualTo(hash),
+    );
+    if (freshlyProvided !== undefined && freshlyProvided.action.kind === UpdatePreimageKind.Provide) {
+      return freshlyProvided.action.preimage.blob;
+    }
+
+    const service = this.state.getService(serviceId);
+    return service?.getPreimage(hash) ?? null;
   }
-}
 
-type ResolveFn = (pvm: Interpreter) => void;
+  /** Get status of a preimage of current service taking into account any updates. */
+  getLookupHistory(
+    currentTimeslot: TimeSlot,
+    serviceId: ServiceId,
+    hash: PreimageHash,
+    length: U64,
+  ): LookupHistoryItem | null {
+    // TODO [ToDr] This is most likely wrong. We may have `provide` and `remove` within
+    // the same state update. We should however switch to proper "updated state"
+    // representation soon.
+    const updatedPreimage = this.stateUpdate.services.preimages.findLast(
+      (update) => update.serviceId === serviceId && update.hash.isEqualTo(hash) && BigInt(update.length) === length,
+    );
 
-declare class InterpreterInstanceManager {
-  private instances: Interpreter[] = [];
-  private waitingQueue: ResolveFn[] = [];
+    const stateFallback = () => {
+      // fallback to state lookup
+      const service = this.state.getService(serviceId);
+      const lenU32 = preimageLenAsU32(length);
+      if (lenU32 === null || service === null) {
+        return null;
+      }
 
-  constructor(noOfPvmInstances: number) {
-    for (let i = 0; i < noOfPvmInstances; i++) {
-      this.instances.push(
-        new Interpreter({
-          useSbrkGas: false,
-        }),
-      );
-    }
-  }
+      const slots = service.getLookupHistory(hash, lenU32);
+      return slots === null ? null : new LookupHistoryItem(hash, lenU32, slots);
+    };
 
-  async getInstance(): Promise<Interpreter> {
-    const instance = this.instances.pop();
-    if (instance !== undefined) {
-      return Promise.resolve(instance);
+    if (updatedPreimage === undefined) {
+      return stateFallback();
     }
-    return new Promise((resolve) => {
-      this.waitingQueue.push(resolve);
-    });
-  }
 
-  releaseInstance(pvm: Interpreter) {
-    const waiting = this.waitingQueue.shift();
-    if (waiting !== undefined) {
-      return waiting(pvm);
+    const { action } = updatedPreimage;
+    switch (action.kind) {
+      case UpdatePreimageKind.Provide: {
+        // casting to U32 is safe, since we compare with object we have in memory.
+        return new LookupHistoryItem(hash, updatedPreimage.length, tryAsLookupHistorySlots([currentTimeslot]));
+      }
+      case UpdatePreimageKind.Remove: {
+        const state = stateFallback();
+        // kinda impossible, since we know it's there because it's removed.
+        if (state === null) {
+          return null;
+        }
+
+        return new LookupHistoryItem(hash, state.length, tryAsLookupHistorySlots([...state.slots, currentTimeslot]));
+      }
+      case UpdatePreimageKind.UpdateOrAdd: {
+        return action.item;
+      }
     }
-    this.instances.push(pvm);
-  }
-}
 
-declare class ReturnValue {
-  private constructor(
-    public consumedGas: Gas,
-    public status: Status | null,
-    public memorySlice: Uint8Array | null,
-  ) {
-    check`
-      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
-      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
-    `;
+    assertNever(action);
   }
 
-  static fromStatus(consumedGas: Gas, status: Status) {
-    return new ReturnValue(consumedGas, status, null);
-  }
+  /* State update functions. */
 
-  static fromMemorySlice(consumedGas: Gas, memorySlice: Uint8Array) {
-    return new ReturnValue(consumedGas, null, memorySlice);
-  }
+  updateStorage(serviceId: ServiceId, key: StorageKey, value: BytesBlob | null) {
+    const update =
+      value === null
+        ? UpdateStorage.remove({ serviceId, key })
+        : UpdateStorage.set({
+            serviceId,
+            storage: StorageItem.create({ key, value }),
+          });
 
-  hasMemorySlice(): this is this & { status: null; memorySlice: Uint8Array } {
-    return this.memorySlice instanceof Uint8Array && this.status === null;
+    const index = this.stateUpdate.services.storage.findIndex(
+      (x) => x.serviceId === update.serviceId && x.key.isEqualTo(key),
+    );
+    const count = index === -1 ? 0 : 1;
+    this.stateUpdate.services.storage.splice(index, count, update);
   }
 
-  hasStatus(): this is this & { status: Status; memorySlice: null } {
-    return !this.hasMemorySlice();
+  /**
+   * Update a preimage.
+   *
+   * Note we store all previous entries as well, since there might be a sequence of:
+   * `provide` -> `remove` and both should update the end state somehow.
+   */
+  updatePreimage(newUpdate: UpdatePreimage) {
+    this.stateUpdate.services.preimages.push(newUpdate);
   }
-}
-declare class HostCalls {
-  constructor(
-    private pvmInstanceManager: InterpreterInstanceManager,
-    private hostCalls: HostCallsManager,
-  ) {}
-
-  private getReturnValue(status: Status, pvmInstance: Interpreter): ReturnValue {
-    const gasConsumed = pvmInstance.getGasConsumed();
-    if (status === Status.OOG) {
-      return ReturnValue.fromStatus(gasConsumed, status);
-    }
 
-    if (status === Status.HALT) {
-      const memory = pvmInstance.getMemory();
-      const regs = pvmInstance.getRegisters();
-      const maybeAddress = regs.getLowerU32(7);
-      const maybeLength = regs.getLowerU32(8);
+  updateServiceStorageUtilisation(
+    serviceId: ServiceId,
+    items: number,
+    bytes: bigint,
+    serviceInfo: ServiceAccountInfo,
+  ): Result$2<OK, InsufficientFundsError> {
+    check`${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
+    check`${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
 
-      const result = safeAllocUint8Array(maybeLength);
-      const startAddress = tryAsMemoryIndex(maybeAddress);
-      const loadResult = memory.loadInto(result, startAddress);
+    const overflowItems = !isU32(items);
+    const overflowBytes = !isU64(bytes);
 
-      if (loadResult.isError) {
-        return ReturnValue.fromMemorySlice(gasConsumed, new Uint8Array());
-      }
+    // TODO [ToDr] this is not specified in GP, but it seems sensible.
+    if (overflowItems || overflowBytes) {
+      return Result.error(InsufficientFundsError);
+    }
 
-      return ReturnValue.fromMemorySlice(gasConsumed, result);
+    const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(items, bytes, serviceInfo.gratisStorage);
+    if (serviceInfo.balance < thresholdBalance) {
+      return Result.error(InsufficientFundsError);
     }
 
-    return ReturnValue.fromStatus(gasConsumed, Status.PANIC);
+    // Update service info with new details.
+    this.updateServiceInfo(
+      serviceId,
+      ServiceAccountInfo.create({
+        ...serviceInfo,
+        storageUtilisationBytes: bytes,
+        storageUtilisationCount: items,
+      }),
+    );
+    return Result.ok(OK);
   }
 
-  private async execute(pvmInstance: Interpreter) {
-    pvmInstance.runProgram();
-    for (;;) {
-      let status = pvmInstance.getStatus();
-      if (status !== Status.HOST) {
-        return this.getReturnValue(status, pvmInstance);
-      }
-      check`
-        ${pvmInstance.getExitParam() !== null}
-        "We know that the exit param is not null, because the status is 'Status.HOST'
-      `;
-      const hostCallIndex = pvmInstance.getExitParam() ?? -1;
-      const gas = pvmInstance.getGasCounter();
-      const regs = new HostCallRegisters(pvmInstance.getRegisters());
-      const memory = new HostCallMemory(pvmInstance.getMemory());
-      const index = tryAsHostCallIndex(hostCallIndex);
-
-      const hostCall = this.hostCalls.get(index);
-      const gasBefore = gas.get();
-      // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
-      const basicGasCost =
-        typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
-      const underflow = gas.sub(basicGasCost);
+  updateServiceInfo(serviceId: ServiceId, newInfo: ServiceAccountInfo) {
+    const idx = this.stateUpdate.services.servicesUpdates.findIndex((x) => x.serviceId === serviceId);
+    const toRemove = idx === -1 ? 0 : 1;
+    const existingItem = this.stateUpdate.services.servicesUpdates[idx];
 
-      const pcLog = `[PC: ${pvmInstance.getPC()}]`;
-      if (underflow) {
-        this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
-        return ReturnValue.fromStatus(pvmInstance.getGasConsumed(), Status.OOG);
-      }
-      this.hostCalls.traceHostCall(`${pcLog} Invoking`, index, hostCall, regs, gasBefore);
-      const result = await hostCall.execute(gas, regs, memory);
-      this.hostCalls.traceHostCall(
-        result === undefined ? `${pcLog} Result` : `${pcLog} Status(${PvmExecution[result]})`,
-        index,
-        hostCall,
-        regs,
-        gas.get(),
+    if (existingItem?.action.kind === UpdateServiceKind.Create) {
+      this.stateUpdate.services.servicesUpdates.splice(
+        idx,
+        toRemove,
+        UpdateService.create({
+          serviceId,
+          serviceInfo: newInfo,
+          lookupHistory: existingItem.action.lookupHistory,
+        }),
       );
 
-      if (result === PvmExecution.Halt) {
-        status = Status.HALT;
-        return this.getReturnValue(status, pvmInstance);
-      }
-
-      if (result === PvmExecution.Panic) {
-        status = Status.PANIC;
-        return this.getReturnValue(status, pvmInstance);
-      }
-
-      if (result === PvmExecution.OOG) {
-        status = Status.OOG;
-        return this.getReturnValue(status, pvmInstance);
-      }
-
-      if (result === undefined) {
-        pvmInstance.runProgram();
-        status = pvmInstance.getStatus();
-        continue;
-      }
-
-      assertNever(result);
+      return;
     }
+
+    this.stateUpdate.services.servicesUpdates.splice(
+      idx,
+      toRemove,
+      UpdateService.update({
+        serviceId,
+        serviceInfo: newInfo,
+      }),
+    );
   }
 
-  async runProgram(
-    rawProgram: Uint8Array,
-    initialPc: number,
-    initialGas: Gas,
-    maybeRegisters?: Registers,
-    maybeMemory?: Memory,
-  ): Promise<ReturnValue> {
-    const pvmInstance = await this.pvmInstanceManager.getInstance();
-    pvmInstance.reset(rawProgram, initialPc, initialGas, maybeRegisters, maybeMemory);
-    try {
-      return await this.execute(pvmInstance);
-    } finally {
-      this.pvmInstanceManager.releaseInstance(pvmInstance);
+  getPrivilegedServices() {
+    if (this.stateUpdate.privilegedServices !== null) {
+      return this.stateUpdate.privilegedServices;
     }
+
+    return this.state.privilegedServices;
   }
 }
 
-type index$7_HostCallHandler = HostCallHandler;
-type index$7_HostCallMemory = HostCallMemory;
-declare const index$7_HostCallMemory: typeof HostCallMemory;
-type index$7_HostCallRegisters = HostCallRegisters;
-declare const index$7_HostCallRegisters: typeof HostCallRegisters;
-type index$7_IHostCallMemory = IHostCallMemory;
-type index$7_IHostCallRegisters = IHostCallRegisters;
-type index$7_PvmExecution = PvmExecution;
-declare const index$7_PvmExecution: typeof PvmExecution;
-declare const index$7_traceRegisters: typeof traceRegisters;
-declare const index$7_tryAsHostCallIndex: typeof tryAsHostCallIndex;
-declare namespace index$7 {
-  export { index$7_HostCallMemory as HostCallMemory, index$7_HostCallRegisters as HostCallRegisters, HostCallsManager as HostCalls, index$7_PvmExecution as PvmExecution, HostCalls as PvmHostCallExtension, InterpreterInstanceManager as PvmInstanceManager, index$7_traceRegisters as traceRegisters, index$7_tryAsHostCallIndex as tryAsHostCallIndex };
-  export type { index$7_HostCallHandler as HostCallHandler, index$7_IHostCallMemory as IHostCallMemory, index$7_IHostCallRegisters as IHostCallRegisters };
+declare function preimageLenAsU32(length: U64) {
+  // Safe to convert to Number and U32: we check that len < 2^32 before conversion
+  return length >= 2n ** 32n ? null : tryAsU32(Number(length));
 }
 
+/**
+ * Host call result constants.
+ *
+ * https://graypaper.fluffylabs.dev/#/85129da/2c7c022c7c02?v=0.6.3
+ */
+declare const HostCallResult = {
+  /** The return value indicating an item does not exist. */
+  NONE: tryAsU64(0xffff_ffff_ffff_ffffn), // 2**64 - 1
+  /** Name unknown. */
+  WHAT: tryAsU64(0xffff_ffff_ffff_fffen), // 2**64 - 2
+  /** The inner PVM memory index provided for reading/writing is not accessible. */
+  OOB: tryAsU64(0xffff_ffff_ffff_fffdn), // 2**64 - 3
+  /** Index unknown. */
+  WHO: tryAsU64(0xffff_ffff_ffff_fffcn), // 2**64 - 4
+  /** Storage full or resource already allocated. */
+  FULL: tryAsU64(0xffff_ffff_ffff_fffbn), // 2**64 - 5
+  /** Core index unknown. */
+  CORE: tryAsU64(0xffff_ffff_ffff_fffan), // 2**64 - 6
+  /** Insufficient funds. */
+  CASH: tryAsU64(0xffff_ffff_ffff_fff9n), // 2**64 - 7
+  /** Gas limit too low. */
+  LOW: tryAsU64(0xffff_ffff_ffff_fff8n), // 2**64 - 8
+  /** The item is already solicited, cannot be forgotten or the operation is invalid due to privilege level. */
+  HUH: tryAsU64(0xffff_ffff_ffff_fff7n), // 2**64 - 9
+  /** The return value indicating general success. */
+  OK: tryAsU64(0n),
+} as const;
+
 declare const MAX_U32 = tryAsU32(2 ** 32 - 1);
 declare const MAX_U32_BIG_INT = tryAsU64(MAX_U32);
 declare const SERVICE_ID_BYTES = 4;
@@ -19281,7 +19559,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 +19567,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 +19882,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 +19901,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 +20006,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>();